core/redAcore
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Major Update:

Browse Source 
- DataTreeCore:
  - Merge TDataMember and CDataTree into => CDataMember
  - Each node, incl root is now CDataMember object
  - Modified function to not require BaseMember (Object is basemember)
  - Split/duplicat most functions to require, or not require child path
  - Added isNull/Object/Array/Sting() etc methods
  - Many other methods removed or restructured
- Updated DataTree usage in: JSONparseCore,
  ApplicationCore, FunctionCore, SelectableCore, WatchdogCore
This commit is contained in:
Charl Wentzel
2018-11-17 19:10:59 +02:00
parent d36bf3230b
commit f2a1ca950a
10 changed files with 472 additions and 488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
ApplicationCore.cpp
View File

@@ -39,7 +39,7 @@ CApplication::CApplication( EDebugLevel pLogLevel )
LogOutput = OUT_NORMAL; LogOutput = OUT_NORMAL;
// Create Configuration // Create Configuration
DataTree = new CDataTree(); DataTree = new CDataMember();
JSONparser = new CJSONparse( DataTree ); JSONparser = new CJSONparse( DataTree );
// Selector // Selector
@@ -145,14 +145,14 @@ bool CApplication::SaveConfig()
bool CApplication::LoadConfigData() bool CApplication::LoadConfigData()
{ {
TDataMember * TempMember; CDataMember * TempMember;
EDebugLevel pLogLevel; EDebugLevel pLogLevel;
int pLogOutput; int pLogOutput;
char * TempStr; char * TempStr;
// Get debug level // Get debug level
pLogLevel = dlNone; pLogLevel = dlNone;
TempStr = (char*)DataTree->GetStr( ConfigMember, "Log/Level", "Medium", true ); TempStr = (char*)ConfigMember->GetChildStr( "Log/Level", "Medium", true );
if (TempStr) if (TempStr)
{ {
if (!strcasecmp( TempStr, "Low" )) if (!strcasecmp( TempStr, "Low" ))
@@ -165,32 +165,35 @@ bool CApplication::LoadConfigData()
// Set debug output // Set debug output
pLogOutput = 0; pLogOutput = 0;
TempMember = DataTree->GetFirstChild( ConfigMember, "Log/Output", true ); if ((TempMember = ConfigMember->GetMember( "Log/Output", true )))
while (TempMember)
{ {
if (TempMember->Value) TempMember = TempMember->GetFirstChild();
while (TempMember)
{ {
if (!strcasecmp( TempMember->Value, "Normal")) if ((TempStr = (char*)TempMember->GetStr()))
pLogOutput |= OUT_NORMAL; {
else if (!strcasecmp( TempMember->Value, "Bin")) if (!strcasecmp( TempStr, "Normal"))
pLogOutput |= OUT_BIN; pLogOutput |= OUT_NORMAL;
else if (!strcasecmp( TempMember->Value, "Hex")) else if (!strcasecmp( TempStr, "Bin"))
pLogOutput |= OUT_HEX; pLogOutput |= OUT_BIN;
else if (!strcasecmp( TempMember->Value, "Count")) else if (!strcasecmp( TempStr, "Hex"))
pLogOutput |= OUT_COUNT; pLogOutput |= OUT_HEX;
else if (!strcasecmp( TempMember->Value, "AsIs")) else if (!strcasecmp( TempStr, "Count"))
pLogOutput |= OUT_ASIS; pLogOutput |= OUT_COUNT;
else if (!strcasecmp( TempMember->Value, "CRLF")) else if (!strcasecmp( TempStr, "AsIs"))
pLogOutput |= OUT_CRLF; pLogOutput |= OUT_ASIS;
} else if (!strcasecmp( TempStr, "CRLF"))
pLogOutput |= OUT_CRLF;
}
// Next // Next
TempMember = DataTree->GetNextChild( TempMember ); TempMember = TempMember->GetNextPeer();
}
} }
SetLogParam( pLogLevel, pLogOutput ); SetLogParam( pLogLevel, pLogOutput );
// Load Address List // 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 (JSONparser->ReadFromFile( "address", AddressFile )) {
if (Log) Log->Message( dlLow, dlLow, "%s: Address file loaded (%s)", ProcessName, AddressFile ); if (Log) Log->Message( dlLow, dlLow, "%s: Address file loaded (%s)", ProcessName, AddressFile );
@@ -201,10 +204,10 @@ bool CApplication::LoadConfigData()
} }
// Configure Selector // Configure Selector
if ((TempMember = DataTree->GetMember( ConfigMember, "Selector" ))) if ((TempMember = ConfigMember->GetMember( "Selector" )))
{ {
// Create 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; return true;
} }
@@ -232,7 +235,7 @@ bool CApplication::Init()
bool CApplication::InitConfig( const char * pConfigPath ) bool CApplication::InitConfig( const char * pConfigPath )
{ {
// Check if Datatree exists // Check if Datatree exists
if (!DataTree || !(ConfigMember = DataTree->GetMember( NULL, pConfigPath ))) { if (!DataTree || !(ConfigMember = DataTree->GetMember( pConfigPath ))) {
return false; return false;
} }
@@ -247,32 +250,32 @@ bool CApplication::InitConfig( const char * pConfigPath )
bool CApplication::InitFunctions( const char * pConfigPath ) bool CApplication::InitFunctions( const char * pConfigPath )
{ {
CFunctionCore * Function; CFunctionCore * Function;
TDataMember * TempMember; CDataMember * TempMember;
char * Type; char * Type;
// Check of path exists // Check of path exists
if (!DataTree || !(FunctionConfigMember = DataTree->GetMember( NULL, pConfigPath ))) if (!DataTree || !(FunctionConfigMember = DataTree->GetMember( pConfigPath )))
return false; return false;
// Process each Channel // Process each Channel
TempMember = DataTree->GetFirstChild( FunctionConfigMember ); TempMember = FunctionConfigMember->GetFirstChild();
while (TempMember) while (TempMember)
{ {
// Get function parameters // Get function parameters
Type = (char*)DataTree->GetStr( TempMember, "Type", "Custom", true ); Type = (char*)TempMember->GetChildStr( "Type", "Custom", true );
// Get or create function // Get or create function
if (!strcasecmp( Type, "WatchdogClient" )) { if (!strcasecmp( Type, "WatchdogClient" )) {
Function = new CWatchdogCore( TempMember->Name ); Function = new CWatchdogCore( TempMember->GetName() );
} }
else if (!strcasecmp( Type, "Selectable" )) { else if (!strcasecmp( Type, "Selectable" )) {
Function = new CSelectableCore( TempMember->Name ); Function = new CSelectableCore( TempMember->GetName() );
} }
else if (!strcasecmp( Type, "File" )) { else if (!strcasecmp( Type, "File" )) {
Function = new CFileCore( TempMember->Name ); Function = new CFileCore( TempMember->GetName() );
} }
else { else {
Function = GetFunction( TempMember->Name ); Function = GetFunction( TempMember->GetName() );
} }
// Load Function configuration and Initialise // Load Function configuration and Initialise
@@ -281,7 +284,7 @@ bool CApplication::InitFunctions( const char * pConfigPath )
} }
// Next // Next
TempMember = TempMember->Next; TempMember = TempMember->GetNextPeer();
} }
return true; return true;
@@ -291,10 +294,10 @@ bool CApplication::InitFunctions( const char * pConfigPath )
bool CApplication::InitFunctionLinks( const char * pConfigPath ) bool CApplication::InitFunctionLinks( const char * pConfigPath )
{ {
TFunctionItem * FunctionItem; TFunctionItem * FunctionItem;
TDataMember * TempMember; CDataMember * TempMember;
// Check of path exists // Check of path exists
if (!DataTree || !(LinkConfigMember = DataTree->GetMember( NULL, pConfigPath ))) if (!DataTree || !(LinkConfigMember = DataTree->GetMember( pConfigPath )))
return false; return false;
// Process each Channel // Process each Channel
@@ -302,7 +305,7 @@ bool CApplication::InitFunctionLinks( const char * pConfigPath )
while (FunctionItem) while (FunctionItem)
{ {
// Build links for function // Build links for function
if ((TempMember = DataTree->GetMember( LinkConfigMember, FunctionItem->Function->GetName() ))) if ((TempMember = LinkConfigMember->GetMember( FunctionItem->Function->GetName() )))
FunctionItem->Function->InitChannelLinks( TempMember ); FunctionItem->Function->InitChannelLinks( TempMember );
// Next // Next

8
ApplicationCore.h
View File

@@ -52,15 +52,15 @@ protected:
int LogOutput; int LogOutput;
// Configuration // Configuration
TDataMember * ConfigMember; CDataMember * ConfigMember;
TDataMember * FunctionConfigMember; CDataMember * FunctionConfigMember;
TDataMember * LinkConfigMember; CDataMember * LinkConfigMember;
bool LoadConfigData(); bool LoadConfigData();
public: public:
// Public function vars // Public function vars
CDataTree * DataTree; CDataMember * DataTree;
CLogCore * Log; CLogCore * Log;
CSelect * Selector; CSelect * Selector;
CJSONparse * JSONparser = NULL; CJSONparse * JSONparser = NULL;

488
DataTreeCore.cpp
View File

@@ -14,111 +14,126 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
CDataTree::CDataTree() CDataMember::CDataMember( const char * pName, const int pLen )
{ {
// Create Root member of tree if (Name) {
RootMember = CreateMember( NULL, NULL, NULL ); NameLen = (pLen == -1)? strlen( pName ) : pLen ;
RootMember->Type = jtObject; Name = (char *)malloc( NameLen+1 );
} memcpy( Name, pName, NameLen );
//--------------------------------------------------------------------------- Name[ NameLen ] = 0;
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;
} }
// Update Parent Type = jtNull;
if (Parent) {
Member->Parent = Parent; 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++; 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; // Remove from parent
if (Parent)
// Validate Parent->Len--;
if (!Member || !*Member) if (this == Parent->LastChild) {
return false; Parent->LastChild = PrevPeer;
// 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) );
} }
PrevPeer->NextPeer = NextPeer;
NextPeer->PrevPeer = PrevPeer;
free( *Member ); // Destroy value/children
Clear();
// Restore list integrity // Destroy member
*Member = NextMember; 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; return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CDataTree::DestroyValue( TDataMember * Member ) CDataMember * CDataMember::GetMember( const char * Path, bool Create )
{ {
// Validate CDataMember * Member;
if (!Member) CDataMember ** Child;
return false; CDataMember * PrevChild;
// 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;
char * Pos; char * Pos;
char * EndPos; char * EndPos;
char * Key; char * Key;
@@ -129,14 +144,12 @@ TDataMember ** CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
// Validate // Validate
if (!Path || !*Path) { if (!Path || !*Path) {
if (Parent) *Parent = NULL; return this;
return NULL;
} }
// Set init references // Set init references
if (Parent) *Parent = NULL;
Child = NULL; Child = NULL;
Member = (BaseMember)? BaseMember : RootMember; Member = this;
// Split path // Split path
Pos = (char*)Path; Pos = (char*)Path;
@@ -182,7 +195,7 @@ TDataMember ** CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
Child = &(Member->FirstChild); Child = &(Member->FirstChild);
while (*Child) { while (*Child) {
PrevChild = *Child; PrevChild = *Child;
Child = &((*Child)->Next); Child = &((*Child)->NextPeer);
} }
} }
else { else {
@@ -197,7 +210,7 @@ TDataMember ** CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
Count = 0; Count = 0;
while (*Child && (Count < Index)) { while (*Child && (Count < Index)) {
PrevChild = *Child; PrevChild = *Child;
Child = &((*Child)->Next); Child = &((*Child)->NextPeer);
Count++; Count++;
} }
} }
@@ -205,7 +218,7 @@ TDataMember ** CDataTree::GetMemberPtr( TDataMember * BaseMember, const char *
// Create element if needed // Create element if needed
if (!*Child && Create) { if (!*Child && Create) {
if ((Index == -1) || (Index = Count + 1)) { 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); Child = &(Member->FirstChild);
while (*Child && (((*Child)->NameLen != KeyLen) || strncasecmp( (*Child)->Name, Key, KeyLen ))) { while (*Child && (((*Child)->NameLen != KeyLen) || strncasecmp( (*Child)->Name, Key, KeyLen ))) {
PrevChild = *Child; PrevChild = *Child;
Child = &((*Child)->Next); Child = &((*Child)->NextPeer);
} }
if (!*Child && Create) { if (!*Child && Create) {
*Child = CreateMember( Member, PrevChild, Key, KeyLen ); *Child = new CDataMember( this, Key, KeyLen );
} }
} }
// Set Parent
if (Last && Parent) {
*Parent = Member;
}
// Next level // Next level
Member = *Child; 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 // Find member
if (!Path || !*Path) { Member = (!Path || !*Path)? this : GetMember( Path, false );
return ((BaseMember)? BaseMember : NULL);
} else { // Check if valid type
Member = GetMemberPtr( BaseMember, Path, Create ); if (!Member || ((Member->Type != jtObject) && (Member->Type != jtNull))) {
return ((Member)? *Member : NULL); 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; int Count;
// Get Parent // Find Member
if (!Parent) Member = (!Path || !*Path)? this : GetMember( Path, false );
return NULL;
// Get Indexed child // Check if valid type
if (!Member || ((Member->Type != jtArray) && (Member->Type != jtNull))) {
return NULL;
}
// Find element at position
Count = 0; Count = 0;
Child = Parent->FirstChild; Child = Member->FirstChild;
while (Child && (Count < Index)) { while (Child && (Count < Index)) {
Child = Child->Next; Child = Child->NextPeer;
Count++; 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; CDataMember * 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;
}
if (!Path || !*Path) { if (!Path || !*Path) {
// No path - destroy value // No path - destroy value
DestroyValue( BaseMember ); Clear();
return true; return true;
} }
else if ((Member = GetMemberPtr( BaseMember, Path, false, &Parent ))) { else if ((Member = GetMember( Path, false ))) {
// If valid path, destroy member // If valid path, destroy member
DestroyMember( Member ); delete Member;
return true; return true;
} }
else { 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 Clear();
while (RootMember->FirstChild) { Type = pType;
DestroyMember( &(RootMember->FirstChild) );
}
return true;
}
//---------------------------------------------------------------------------
bool CDataTree::SetValuePtr( TDataMember * Member, EDataType Type, char * Value, int Len ) if ((pType == jtString) || (pType == jtFloat) || (pType == jtInt) || (pType == jtBool))
{
// 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))
{ {
// Validate Len = (pLen == -1)? strlen(pValue) : pLen;
if (!Value) { Value = (char*)malloc( Len+1 );
return false; memcpy( Value, pValue, Len );
} Value[Len] = 0;
// 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 );
} }
return true; return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CDataTree::SetObject( TDataMember * BaseMember, const char * Path ) bool CDataMember::SetChildObject( const char * Path )
{ {
TDataMember * Member; CDataMember * Member;
// Validate // Validate
if (!(Member = GetMember( BaseMember, Path, true ))) { if (!(Member = GetMember( Path, true ))) {
return false; return false;
} }
// Set as Object // Set as Object
SetValue( Member, jtObject, NULL ); Member->SetValue( jtObject, NULL );
return true; return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CDataTree::SetArray( TDataMember * BaseMember, const char * Path ) bool CDataMember::SetChildArray( const char * Path )
{ {
TDataMember * Member; CDataMember * Member;
// Validate // Validate
if (!(Member = GetMember( BaseMember, Path, true ))) { if (!(Member = GetMember( Path, true ))) {
return false; return false;
} }
// Set as Object // Set as Object
SetValue( Member, jtArray, NULL ); Member->SetValue( jtArray, NULL );
return true; 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 // Validate
if (!(Member = GetMember( BaseMember, Path, true ))) { if (!(Member = GetMember( Path, true ))) {
return false; return false;
} }
// Create Value // Create Value
SetValue( Member, jtString, Value, Len ); if (!Value) {
Member->SetValue( jtString, "", 0 );
}
else {
Member->SetValue( jtString, Value, Len );
}
return true; 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]; char ValueStr[20];
// Validate // Validate
if (!(Member = GetMember( BaseMember, Path, true ))) { if (!(Member = GetMember( Path, true ))) {
return false; return false;
} }
// Create Value // Create Value
sprintf( ValueStr, ((Mask)? Mask : "%ld"), Value ); sprintf( ValueStr, ((Mask)? Mask : "%ld"), Value );
SetValue( Member, jtInt, ValueStr ); Member->SetValue( jtInt, ValueStr );
return true; 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]; char ValueStr[20];
// Validate // Validate
if (!(Member = GetMember( BaseMember, Path, true ))) { if (!(Member = GetMember( Path, true ))) {
return false; return false;
} }
// Create Value // Create Value
sprintf( ValueStr, ((Mask)? Mask : "%lf"), Value ); sprintf( ValueStr, ((Mask)? Mask : "%lf"), Value );
SetValue( Member, jtFloat, ValueStr ); Member->SetValue( jtFloat, ValueStr );
return true; 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 // Validate
if (!(Member = GetMember( BaseMember, Path, true ))) { if (!(Member = GetMember( Path, true ))) {
return false; return false;
} }
// Create Value // Create Value
SetValue( Member, jtBool, ((Value == 0)? "0" : "1") ); Member->SetValue( jtBool, ((Value == 0)? "0" : "1") );
return true; return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CDataTree::SetNull( TDataMember * BaseMember, const char * Path ) bool CDataMember::SetChildNull( const char * Path )
{ {
TDataMember * Member; CDataMember * Member;
// Validate // Validate
if (!(Member = GetMember( BaseMember, Path, true ))) { if (!(Member = GetMember( Path, true ))) {
return false; return false;
} }
// Create Value // Create Value
SetValue( Member, jtNull, NULL ); Member->SetValue( jtNull, NULL );
return true; return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EDataType CDataTree::GetType( TDataMember * BaseMember, const char * Path ) const char * CDataMember::GetName( const char * Path )
{ {
TDataMember * Member; CDataMember * Member;
// Validate // 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 jtNull;
} }
return Member->Type; 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 // 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)) ) { ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
return Member->Value; return Member->Value;
} }
else if (Member && Create && (Member->Type == jtNull)) { else if (Member && Create && (Member->Type == jtNull)) {
SetValue( Member, jtString, Default ); Member->SetValue( jtString, Default );
return Member->Value; return Member->Value;
} }
else { 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 // Validate
if ((Member = GetMember( BaseMember, Path, Create )) && if ((Member = GetMember( Path, Create )) &&
((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) { ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
Len = Member->Len; Len = Member->Len;
return Member->Value; return Member->Value;
} }
else if (Member && Create && (Member->Type == jtNull)) { else if (Member && Create && (Member->Type == jtNull)) {
SetValue( Member, jtString, Default ); Member->SetValue( jtString, Default );
Len = Member->Len; Len = Member->Len;
return Member->Value; 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 // Validate
if ((Member = GetMember( BaseMember, Path, false )) && if ((Member = GetMember( Path, Create )) &&
((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 )) &&
((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) { ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
return strtol( Member->Value, NULL, 10 ); return strtol( Member->Value, NULL, 10 );
} }
else if (Member && Create && (Member->Type == jtNull)) { else if (Member && Create && (Member->Type == jtNull)) {
char TempStr[20]; char TempStr[20];
sprintf( TempStr, ((Mask)? Mask : "%ld"), Default ); sprintf( TempStr, ((Mask)? Mask : "%ld"), Default );
SetValue( Member, jtInt, TempStr ); Member->SetValue( jtInt, TempStr );
return Default; return Default;
} }
else { 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 // Validate
if ((Member = GetMember( BaseMember, Path, Create )) && if ((Member = GetMember( Path, Create )) &&
((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) { ((Member->Type == jtString) || (Member->Type == jtFloat) || (Member->Type == jtInt) || (Member->Type == jtBool)) ) {
return strtod( Member->Value, NULL ); return strtod( Member->Value, NULL );
} }
else if (Member && Create && (Member->Type == jtNull)) { else if (Member && Create && (Member->Type == jtNull)) {
char TempStr[20]; char TempStr[20];
sprintf( TempStr, ((Mask)? Mask : "%lf"), Default ); sprintf( TempStr, ((Mask)? Mask : "%lf"), Default );
SetValue( Member, jtFloat, TempStr ); Member->SetValue( jtFloat, TempStr );
return Default; return Default;
} }
else { 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 // Validate
if ((Member = GetMember( BaseMember, Path, Create ))) { if ((Member = GetMember( Path, Create ))) {
if (Member->Type == jtString) { if (Member->Type == jtString) {
return ((!*Member->Value)? false : true); 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 ); return ((!strcasecmp( Member->Value, "0" ))? false : true );
} }
else if ((Member->Type == jtNull) && Create) { else if ((Member->Type == jtNull) && Create) {
SetValue( Member, jtBool, ((Default)? "1" : "0") ); Member->SetValue( jtBool, ((Default)? "1" : "0") );
return Default; return Default;
} }
else { else {

115
DataTreeCore.h
View File

@@ -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 // One Config Members
struct SDataMember class CDataMember
{ {
char * Name; char * Name;
unsigned short NameLen; unsigned short NameLen;
EDataType Type; EDataType Type;
TDataMember * FirstChild;
char * Value; char * Value;
unsigned short Len; unsigned short Len;
TDataMember * Parent; CDataMember * FirstChild;
TDataMember * Prev; CDataMember * LastChild;
TDataMember * Next;
};
//--------------------------------------------------------------------------- CDataMember * Parent;
CDataMember * PrevPeer;
class CDataTree CDataMember * NextPeer;
{
private:
TDataMember * RootMember;
// Manage Members // Manage Members
TDataMember * CreateMember( TDataMember * Parent, TDataMember * PrevChild, const char * Name, const int Len = -1 ); CDataMember * CreateChild( 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 );
// Set Member value // Set Member value
bool SetValue( TDataMember * Member, EDataType Type, const char * Value = NULL, int Len = -1 ); bool SetValue( EDataType Type, const char * Value = NULL, int Len = -1 );
bool SetValuePtr( TDataMember * Member, EDataType Type, char * Value, int Len );
public: public:
CDataTree(); CDataMember( const char * pName = NULL, const int pLen = -1 );
~CDataTree(); CDataMember( CDataMember * pParent, const char * pName = NULL, const int pLen = -1 );
~CDataMember();
EDataType GetType( TDataMember * BaseMember, const char * Path ); EDataType GetType() { return Type; };
TDataMember * GetMember( TDataMember * BaseMember, const char * Path, bool Create = false ); EDataType GetType( const char * Path );
TDataMember * GetIndexChild( TDataMember * Parent, const int Index ); inline bool isNull() { return (Type == jtNull); };
TDataMember * GetFirstChild( TDataMember * Parent, const char * Path, bool Create = false ); 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); }; const char * GetName() { return Name; };
inline TDataMember * GetFirstChild( TDataMember * Parent ) { return ((Parent)? Parent->FirstChild : NULL); }; const char * GetName( const char * Path );
inline TDataMember * GetPrevChild( TDataMember * Child ) { return ((Child)? Child->Prev : NULL); };
inline TDataMember * GetNextChild( TDataMember * Child ) { return ((Child)? Child->Next : NULL); };
const char * GetStr( TDataMember * BaseMember, const char * Path, const char * Default = NULL, bool Create = false ); const int GetLen() { return Len; };
const char * GetStr( TDataMember * BaseMember, const char * Path, int &Len, const char * Default = NULL, bool Create = false ); const int GetLen( const char * Path );
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 );
bool SetObject( TDataMember * BaseMember, const char * Path ); CDataMember * GetMember( const char * Path, bool Create = false );
bool SetArray( TDataMember * BaseMember, const char * Path ); CDataMember * GetFirstChild( 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 CDataMember * GetElement( const char * Path, const int Index );
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 );
bool Delete( TDataMember * BaseMember, const char * Path ); inline CDataMember * GetFirstChild() { return FirstChild; };
bool DeleteAll(); 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; friend class CJSONparse;
}; };

83
FunctionCore.cpp
View File

@@ -113,14 +113,14 @@ CFunctionCore::~CFunctionCore()
bool CFunctionCore::LoadConfigData() bool CFunctionCore::LoadConfigData()
{ {
TDataMember * TempMember; CDataMember * TempMember;
EDebugLevel pLogLevel; EDebugLevel pLogLevel;
int pLogOutput; int pLogOutput;
char * TempStr; char * TempStr;
// Get debug level // Get debug level
pLogLevel = dlNone; pLogLevel = dlNone;
TempStr = (char*)DataTree->GetStr( ConfigMember, "Log/Level", "Medium", true ); TempStr = (char*)ConfigMember->GetChildStr( "Log/Level", "Medium", true );
if (TempStr) if (TempStr)
{ {
if (!strcasecmp( TempStr, "Low" )) if (!strcasecmp( TempStr, "Low" ))
@@ -133,44 +133,47 @@ bool CFunctionCore::LoadConfigData()
// Set debug output // Set debug output
pLogOutput = 0; pLogOutput = 0;
TempMember = DataTree->GetFirstChild( ConfigMember, "Log/Output", true ); if ((TempMember = ConfigMember->GetMember( "Log/Output", true )))
while (TempMember)
{ {
if (TempMember->Value) TempMember = TempMember->GetFirstChild();
while (TempMember)
{ {
if (!strcasecmp( TempMember->Value, "Normal")) if ((TempStr = (char*)TempMember->GetStr()))
pLogOutput |= OUT_NORMAL; {
else if (!strcasecmp( TempMember->Value, "Bin")) if (!strcasecmp( TempStr, "Normal"))
pLogOutput |= OUT_BIN; pLogOutput |= OUT_NORMAL;
else if (!strcasecmp( TempMember->Value, "Hex")) else if (!strcasecmp( TempStr, "Bin"))
pLogOutput |= OUT_HEX; pLogOutput |= OUT_BIN;
else if (!strcasecmp( TempMember->Value, "Count")) else if (!strcasecmp( TempStr, "Hex"))
pLogOutput |= OUT_COUNT; pLogOutput |= OUT_HEX;
else if (!strcasecmp( TempMember->Value, "AsIs")) else if (!strcasecmp( TempStr, "Count"))
pLogOutput |= OUT_ASIS; pLogOutput |= OUT_COUNT;
else if (!strcasecmp( TempMember->Value, "CRLF")) else if (!strcasecmp( TempStr, "AsIs"))
pLogOutput |= OUT_CRLF; pLogOutput |= OUT_ASIS;
} else if (!strcasecmp( TempStr, "CRLF"))
pLogOutput |= OUT_CRLF;
}
// Next // Next
TempMember = DataTree->GetNextChild( TempMember ); TempMember = TempMember->GetNextPeer();
}
} }
// Set Logging // Set Logging
SetLogParam( pLogLevel, pLogOutput ); SetLogParam( pLogLevel, pLogOutput );
// Load Channels // Load Channels
TempMember = DataTree->GetFirstChild( ConfigMember, "Channels" ); TempMember = ConfigMember->GetFirstChild( "Channels" );
while (TempMember) while (TempMember)
{ {
if (TempMember->Name) { if (TempMember->GetName()) {
AddChannel( TempMember->Name, AddChannel( TempMember->GetName(),
DataTree->GetBool( TempMember, "InputEnabled", true, true ), TempMember->GetChildBool( "InputEnabled", true, true ),
DataTree->GetBool( TempMember, "OutputEnabled", false, true )); TempMember->GetChildBool( "OutputEnabled", false, true ));
} }
// Next // Next
TempMember = DataTree->GetNextChild( TempMember ); TempMember = TempMember->GetNextPeer();
} }
return true; return true;
@@ -180,29 +183,29 @@ bool CFunctionCore::LoadConfigData()
bool CFunctionCore::LoadChannelLinkData() bool CFunctionCore::LoadChannelLinkData()
{ {
TChannel * Channel; TChannel * Channel;
TDataMember * ChannelMember; CDataMember * ChannelMember;
TDataMember * FunctionMember; CDataMember * FunctionMember;
// Process each Channel // Process each Channel
ChannelMember = DataTree->GetFirstChild( LinkConfigMember ); ChannelMember = LinkConfigMember->GetFirstChild();
while (ChannelMember) while (ChannelMember)
{ {
if ((Channel = GetChannel( ChannelMember->Name ))) if ((Channel = GetChannel( ChannelMember->GetName() )))
{ {
FunctionMember = DataTree->GetFirstChild( ChannelMember ); FunctionMember = ChannelMember->GetFirstChild();
while (FunctionMember) while (FunctionMember)
{ {
// Get Parameters // Get Parameters
LinkOutputChannel( Channel->Name, LinkOutputChannel( Channel->Name,
DataTree->GetStr( FunctionMember, "Function" ), FunctionMember->GetChildStr( "Function" ),
DataTree->GetStr( FunctionMember, "Channel" ), FunctionMember->GetChildStr( "Channel" ),
DataTree->GetBool( FunctionMember, "Bidirectional" ) ); FunctionMember->GetChildBool( "Bidirectional" ) );
// Next // Next
FunctionMember = DataTree->GetNextChild( FunctionMember ); FunctionMember = FunctionMember->GetNextPeer();
} }
} }
// Next // Next
ChannelMember = DataTree->GetNextChild( ChannelMember ); ChannelMember = ChannelMember->GetNextPeer();
} }
return true; return true;
@@ -221,7 +224,7 @@ bool CFunctionCore::Init()
bool CFunctionCore::InitConfig( const char * pConfigPath ) bool CFunctionCore::InitConfig( const char * pConfigPath )
{ {
// Validate // Validate
if (!DataTree || !(ConfigMember = DataTree->GetMember( NULL, pConfigPath, true ))) if (!DataTree || !(ConfigMember = DataTree->GetMember( pConfigPath, true )))
return false; return false;
// Load configuration // Load configuration
@@ -232,7 +235,7 @@ bool CFunctionCore::InitConfig( const char * pConfigPath )
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CFunctionCore::InitConfig( TDataMember * pBaseMember ) bool CFunctionCore::InitConfig( CDataMember * pBaseMember )
{ {
// Validate // Validate
if (!DataTree || !(ConfigMember = pBaseMember )) if (!DataTree || !(ConfigMember = pBaseMember ))
@@ -249,7 +252,7 @@ bool CFunctionCore::InitConfig( TDataMember * pBaseMember )
bool CFunctionCore::InitChannelLinks( const char * pLinkConfigPath ) bool CFunctionCore::InitChannelLinks( const char * pLinkConfigPath )
{ {
// Validate // Validate
if (!DataTree || !(LinkConfigMember = DataTree->GetMember( NULL, pLinkConfigPath, true ))) if (!DataTree || !(LinkConfigMember = DataTree->GetMember( pLinkConfigPath, true )))
return false; return false;
// Load configuration // Load configuration
@@ -259,7 +262,7 @@ bool CFunctionCore::InitChannelLinks( const char * pLinkConfigPath )
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CFunctionCore::InitChannelLinks( TDataMember *pLinkConfigMember ) bool CFunctionCore::InitChannelLinks( CDataMember *pLinkConfigMember )
{ {
// Validate // Validate
if (!DataTree || !(LinkConfigMember = pLinkConfigMember)) if (!DataTree || !(LinkConfigMember = pLinkConfigMember))

10
FunctionCore.h
View File

@@ -56,9 +56,9 @@ protected:
char * Type; char * Type;
// Configuration // Configuration
CDataTree * DataTree; CDataMember * DataTree;
TDataMember * ConfigMember; CDataMember * ConfigMember;
TDataMember * LinkConfigMember; CDataMember * LinkConfigMember;
// Channels // Channels
TChannel * FirstChannel; TChannel * FirstChannel;
@@ -98,10 +98,10 @@ public:
virtual bool Init(); virtual bool Init();
bool InitConfig( const char * pConfigPath ); bool InitConfig( const char * pConfigPath );
bool InitConfig( TDataMember * pConfigMember ); bool InitConfig( CDataMember * pConfigMember );
bool InitChannelLinks( const char * pLinkConfigPath ); bool InitChannelLinks( const char * pLinkConfigPath );
bool InitChannelLinks( TDataMember *pLinkConfigMember ); bool InitChannelLinks( CDataMember *pLinkConfigMember );
// Set Parameters Manually // Set Parameters Manually
bool SetLogParam( EDebugLevel pDebugLevel, int pOutputDisplay ); bool SetLogParam( EDebugLevel pDebugLevel, int pOutputDisplay );

73
JSONparseCore.cpp
View File

@@ -15,7 +15,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
CJSONparse::CJSONparse( CDataTree * pDataTree ) CJSONparse::CJSONparse( CDataMember * pDataTree )
{ {
// Object tree // Object tree
DataTree = pDataTree; 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 ) bool CJSONparse::WriteToHandle( const char * BasePath, const int Handle, const int Indent )
{ {
TDataMember * BaseMember; CDataMember * Member;
// Validate // Validate
if (!DataTree) { if (!DataTree) {
@@ -136,17 +136,14 @@ bool CJSONparse::WriteToHandle( const char * BasePath, const int Handle, const i
OutputHandle = Handle; OutputHandle = Handle;
// Get Root object // Get Root object
if (!BasePath || !*BasePath) { if (!(Member = DataTree->GetMember( BasePath ))) {
BaseMember = DataTree->GetRootMember();
}
else if (!(BaseMember = DataTree->GetMember( NULL, BasePath ))) {
Error = true; Error = true;
sprintf( ErrorText, "Invalid root object path" ); sprintf( ErrorText, "Invalid root object path" );
return false; return false;
} }
// Print to file // Print to file
PrintObject( BaseMember, Indent ); PrintObject( Member, Indent );
write( OutputHandle, "\n", 1 ); write( OutputHandle, "\n", 1 );
OutputHandle = -1; OutputHandle = -1;
@@ -279,7 +276,7 @@ bool CJSONparse::ReadFromString( const char * BasePath, const char * InString, c
bool CJSONparse::ReadFromBuffer( const char * BasePath ) bool CJSONparse::ReadFromBuffer( const char * BasePath )
{ {
TDataMember * BaseMember = NULL; CDataMember * BaseMember = NULL;
// Validate // Validate
if (!DataTree || !Buffer) { if (!DataTree || !Buffer) {
@@ -290,17 +287,14 @@ bool CJSONparse::ReadFromBuffer( const char * BasePath )
Error = false; Error = false;
// Get/Create Root object // Get/Create Root object
if (!BasePath || !*BasePath) { if (!(BaseMember = DataTree->GetMember( BasePath, true ))) {
BaseMember = DataTree->GetRootMember();
}
else if (!(BaseMember = DataTree->GetMember( NULL, BasePath, true ))) {
Error = true; Error = true;
sprintf( ErrorText, "Invalid root object path" ); sprintf( ErrorText, "Invalid root object path" );
return false; return false;
} }
// Delete existing object contents // Delete existing object contents
DataTree->Delete( BaseMember, NULL ); BaseMember->Clear();
// Position Counters // Position Counters
LineNo = 1; 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; char * MemberName = NULL;
int Len = 0; int Len = 0;
@@ -550,7 +544,7 @@ bool CJSONparse::ParseObject( TDataMember * Object )
BufPos++; BufPos++;
// Set Type // Set Type
DataTree->SetValue( Object, jtObject ); Object->SetValue( jtObject );
while (true) while (true)
{ {
@@ -574,7 +568,7 @@ bool CJSONparse::ParseObject( TDataMember * Object )
} }
// Check if Member exists // Check if Member exists
Member = DataTree->GetMember( Object, MemberName, true ); Member = Object->GetMember( MemberName, true );
// Check for delimiter // Check for delimiter
SkipWhiteSpace(); SkipWhiteSpace();
@@ -590,7 +584,7 @@ bool CJSONparse::ParseObject( TDataMember * Object )
if (!ParseObject( Member ) && !Error && !ParseArray( Member ) && !Error && !ParseString( Member ) && !Error && !ParsePrimitive( Member ) ) {} if (!ParseObject( Member ) && !Error && !ParseArray( Member ) && !Error && !ParseString( Member ) && !Error && !ParsePrimitive( Member ) ) {}
if (Error) { if (Error) {
// Destroy member // Destroy member
DataTree->Delete( Object, MemberName ); Object->Delete( MemberName );
return false; return false;
} }
@@ -619,10 +613,9 @@ bool CJSONparse::ParseObject( TDataMember * Object )
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CJSONparse::ParseArray( TDataMember * Array ) bool CJSONparse::ParseArray( CDataMember * Array )
{ {
TDataMember ** Member; CDataMember ** Member;
TDataMember * PrevMember;
// Check for start of Object // Check for start of Object
if (*BufPos != '[') { if (*BufPos != '[') {
@@ -631,9 +624,8 @@ bool CJSONparse::ParseArray( TDataMember * Array )
BufPos++; BufPos++;
// Set Type // Set Type
DataTree->SetValue( Array, jtArray ); Array->SetValue( jtArray );
Member = &(Array->FirstChild); Member = &(Array->FirstChild);
PrevMember = NULL;
while (true) while (true)
{ {
// Look for Member Name // Look for Member Name
@@ -643,18 +635,17 @@ bool CJSONparse::ParseArray( TDataMember * Array )
} }
// Add new element // Add new element
*Member = DataTree->CreateMember( Array, PrevMember, NULL ); *Member = new CDataMember( Array );
// Get Value // Get Value
SkipWhiteSpace(); SkipWhiteSpace();
if (!ParseObject( *Member ) && !Error && !ParseArray( *Member ) && !Error && !ParseString( *Member ) && !Error && !ParsePrimitive( *Member ) ) {} if (!ParseObject( *Member ) && !Error && !ParseArray( *Member ) && !Error && !ParseString( *Member ) && !Error && !ParsePrimitive( *Member ) ) {}
if (Error) { if (Error) {
DataTree->DestroyMember( Member ); delete Member;
return false; return false;
} }
else { else {
PrevMember = *Member; Member = &((*Member)->NextPeer);
Member = &((*Member)->Next);
} }
// Check if more parameters to follow // 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; char * Value = NULL;
int Len = 0; int Len = 0;
@@ -690,13 +681,13 @@ bool CJSONparse::ParseString( TDataMember * Member )
} }
// Set string // Set string
DataTree->SetValuePtr( Member, jtString, Value, Len ); Member->SetValue( jtString, Value, Len );
return true; return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool CJSONparse::ParsePrimitive( TDataMember * Member ) bool CJSONparse::ParsePrimitive( CDataMember * Member )
{ {
char * Value = NULL; char * Value = NULL;
int Len = 0; int Len = 0;
@@ -721,13 +712,13 @@ bool CJSONparse::ParsePrimitive( TDataMember * Member )
// Check for primitive values // Check for primitive values
if ((Len == 4) && !strncasecmp( Mark, "null", 4 )) { 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 )) { 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 )) { else if ((Len == 5) && !strncasecmp( Mark, "false", 5 )) {
DataTree->SetValue( Member, jtBool, "0" ); Member->SetValue( jtBool, "0" );
} }
else { else {
// Try conversion to int // Try conversion to int
@@ -736,7 +727,7 @@ bool CJSONparse::ParsePrimitive( TDataMember * Member )
Value = (char*)malloc( Len+1 ); Value = (char*)malloc( Len+1 );
memcpy( Value, Mark, Len ); memcpy( Value, Mark, Len );
Value[Len] = 0; Value[Len] = 0;
DataTree->SetValuePtr( Member, jtInt, Value, Len ); Member->SetValue( jtInt, Value, Len );
} }
else { else {
// Try conversion to float // Try conversion to float
@@ -745,7 +736,7 @@ bool CJSONparse::ParsePrimitive( TDataMember * Member )
Value = (char*)malloc( Len+1 ); Value = (char*)malloc( Len+1 );
memcpy( Value, Mark, Len ); memcpy( Value, Mark, Len );
Value[Len] = 0; Value[Len] = 0;
DataTree->SetValuePtr( Member, jtFloat, Value, Len ); Member->SetValue( jtFloat, Value, Len );
} }
else { else {
Error = true; 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 First = true;
bool Last = false; bool Last = false;
int Count = 0; int Count = 0;
@@ -824,7 +815,7 @@ bool CJSONparse::PrintObject( TDataMember * Object, const int Indent )
} }
// Save parameters // Save parameters
for (Member = Object->FirstChild; Member != NULL; (Member = Member->Next)) for (Member = Object->FirstChild; Member != NULL; (Member = Member->NextPeer))
{ {
// Whitespace around first bracket // Whitespace around first bracket
if (Indent) { 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 First = true;
bool Last = false; bool Last = false;
int Count = 0; int Count = 0;
@@ -913,7 +904,7 @@ bool CJSONparse::PrintArray( TDataMember * Array, const int Indent )
} }
// Save parameters // Save parameters
for (Member = Array->FirstChild; Member != NULL; (Member = Member->Next)) for (Member = Array->FirstChild; Member != NULL; (Member = Member->NextPeer))
{ {
// Whitespace around brace // Whitespace around brace
if (Indent) { if (Indent) {

16
JSONparseCore.h
View File

@@ -21,7 +21,7 @@
class CJSONparse class CJSONparse
{ {
private: private:
CDataTree * DataTree; CDataMember * DataTree;
// File operation // File operation
int InputHandle; int InputHandle;
@@ -47,17 +47,17 @@ private:
// Parsing functions // Parsing functions
void SkipWhiteSpace(); void SkipWhiteSpace();
bool ParseString( char ** Value, int &pLen ); bool ParseString( char ** Value, int &pLen );
bool ParseObject( TDataMember * Object ); bool ParseObject( CDataMember * Object );
bool ParseArray( TDataMember * Array ); bool ParseArray( CDataMember * Array );
bool ParseString( TDataMember * Member ); bool ParseString( CDataMember * Member );
bool ParsePrimitive( TDataMember * Member ); bool ParsePrimitive( CDataMember * Member );
bool PrintString( char * String, int Len ); bool PrintString( char * String, int Len );
bool PrintObject( TDataMember * Object, const int Indent ); bool PrintObject( CDataMember * Object, const int Indent );
bool PrintArray( TDataMember * Object, const int Indent ); bool PrintArray( CDataMember * Object, const int Indent );
public: public:
CJSONparse( CDataTree * pDataTree ); CJSONparse( CDataMember * pDataTree );
~CJSONparse(); ~CJSONparse();
// Buffer operation // Buffer operation

88
SelectableCore.cpp
View File

@@ -65,8 +65,8 @@ CSelectableCore::~CSelectableCore()
bool CSelectableCore::LoadConfigData() bool CSelectableCore::LoadConfigData()
{ {
TDataMember * TempMember; CDataMember * TempMember;
TDataMember * SerialConfig; CDataMember * SerialConfig;
THandle * Handle; THandle * Handle;
char * Type; char * Type;
char * Name; char * Name;
@@ -83,33 +83,35 @@ bool CSelectableCore::LoadConfigData()
CFunctionCore::LoadConfigData(); CFunctionCore::LoadConfigData();
// Load Handles // Load Handles
TempMember = DataTree->GetFirstChild( DataTree->GetMember( ConfigMember, "Handles", false ) ); if ((TempMember = ConfigMember->GetMember( "Handles", false ))) {
TempMember = TempMember->GetFirstChild();
}
while (TempMember) while (TempMember)
{ {
// Check if name is valid // Check if name is valid
if (!TempMember->Name || !*TempMember->Name) if (!TempMember->GetName() || !*TempMember->GetName())
continue; continue;
// Create Handle and channel link // Create Handle and channel link
Handle = CreateHandle( TempMember->Name, false ); Handle = CreateHandle( TempMember->GetName(), false );
Handle->Channel = GetChannel( DataTree->GetStr( TempMember, "Channel" ) ); 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 (!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 ); 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 { 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 ); SetSerialHandle( Handle, Address );
// Update configuration if specified // 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" )) if (!strcasecmp( ParityText, "none" ))
Parity = NO_PARITY; Parity = NO_PARITY;
else if (!strcasecmp( ParityText, "odd" )) else if (!strcasecmp( ParityText, "odd" ))
@@ -119,7 +121,7 @@ bool CSelectableCore::LoadConfigData()
else if (!strcasecmp( ParityText, "mark" )) else if (!strcasecmp( ParityText, "mark" ))
Parity = MARK_PARITY; Parity = MARK_PARITY;
FlowCtrlText = (char*)DataTree->GetStr( SerialConfig, "FlowCtrl", "none", true ); FlowCtrlText = (char*)SerialConfig->GetChildStr( "FlowCtrl", "none", true );
if (!strcasecmp( FlowCtrlText, "none" )) if (!strcasecmp( FlowCtrlText, "none" ))
FlowCtrl = NO_FLOWCTRL; FlowCtrl = NO_FLOWCTRL;
else if (!strcasecmp( FlowCtrlText, "hardware" )) else if (!strcasecmp( FlowCtrlText, "hardware" ))
@@ -128,73 +130,73 @@ bool CSelectableCore::LoadConfigData()
FlowCtrl = SW_FLOWCTRL; FlowCtrl = SW_FLOWCTRL;
Handle->SerialConfig = true; Handle->SerialConfig = true;
SetSerialHandleConfig( Handle, DataTree->GetInt( SerialConfig, "BaudRate", 19200, true ), SetSerialHandleConfig( Handle, SerialConfig->GetChildInt( "BaudRate", 19200, true ),
DataTree->GetInt( SerialConfig, "DataBits", 8, true ), SerialConfig->GetChildInt( "DataBits", 8, true ),
Parity, DataTree->GetInt( SerialConfig, "StopBits", 1, true ), Parity, SerialConfig->GetChildInt( "StopBits", 1, true ),
FlowCtrl, DataTree->GetInt( SerialConfig, "DataWait", 0, true )); FlowCtrl, SerialConfig->GetChildInt( "DataWait", 0, true ));
} }
} }
else if (!strcasecmp( Type, "LinePrinter" )) 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 ); 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 { 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 ); SetLinePrinterHandle( Handle, Address );
} }
else if (!strcasecmp( Type, "TCPserver" )) 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 ); 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 ); 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 { else {
Address = (char*)DataTree->GetStr( TempMember, "Socket/Address", NULL, true ); // Get default Address value Address = (char*)TempMember->GetChildStr( "Socket/Address", NULL, true ); // Get default Address value
Port = (char*)DataTree->GetStr( TempMember, "Socket/Port", "0", true ); // Get default Port 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 ); SetSocketHandle( Handle, ctServer, Address, strlcase(Port), Delay );
} }
else if (!strcasecmp( Type, "TCPclient" )) 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 ); 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 ); 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 { else {
Address = (char*)DataTree->GetStr( TempMember, "Socket/Address", NULL, true ); // Get default Address value Address = (char*)TempMember->GetChildStr( "Socket/Address", NULL, true ); // Get default Address value
Port = (char*)DataTree->GetStr( TempMember, "Socket/Port", "0", true ); // Get default Port 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 ); SetSocketHandle( Handle, ctClient, Address, strlcase(Port), Delay );
} }
else if (!strcasecmp( Type, "ForkPipe" )) { 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 ); SetForkPipeHandle( Handle, Address );
} }
// Set Auto Mange // Set Auto Mange
SetAutoManage( Handle, DataTree->GetBool( TempMember, "AutoManage/Enabled", true, true ), SetAutoManage( Handle, TempMember->GetChildBool( "AutoManage/Enabled", true, true ),
DataTree->GetBool( TempMember, "AutoManage/Persistent", false, true ), TempMember->GetChildBool( "AutoManage/Persistent", false, true ),
DataTree->GetInt( TempMember, "AutoManage/ReopenDelay", 2000, true ), TempMember->GetChildInt( "AutoManage/ReopenDelay", 2000, true ),
DataTree->GetInt( TempMember, "AutoManage/CloseTimeout", 2000, true )); TempMember->GetChildInt( "AutoManage/CloseTimeout", 2000, true ));
// Input buffer // Input buffer
SetInBuffer( Handle, DataTree->GetInt( TempMember, "InputBuffer/Size", 0 ), SetInBuffer( Handle, TempMember->GetChildInt( "InputBuffer/Size", 0 ),
DataTree->GetInt( TempMember, "InputBuffer/Timeout", 250 ), TempMember->GetChildInt( "InputBuffer/Timeout", 250 ),
DataTree->GetStr( TempMember, "InputBuffer/Marker", "" ), TempMember->GetChildStr( "InputBuffer/Marker", "" ),
DataTree->GetInt( TempMember, "InputBuffer/MarkerLen", 0 ) ); TempMember->GetChildInt( "InputBuffer/MarkerLen", 0 ) );
SetOutBuffer( Handle, DataTree->GetInt( TempMember, "OutputBuffer/Size", 0 ) ); SetOutBuffer( Handle, TempMember->GetChildInt( "OutputBuffer/Size", 0 ) );
// Next // Next
TempMember = DataTree->GetNextChild( TempMember ); TempMember = TempMember->GetNextPeer();
} }
return true; return true;

2
WatchdogCore.cpp
View File

@@ -50,7 +50,7 @@ bool CWatchdogCore::LoadConfigData()
CSelectableCore::LoadConfigData(); CSelectableCore::LoadConfigData();
// Set specific parameters // Set specific parameters
SetInterval( DataTree->GetInt( ConfigMember, "Parameters/PingInterval", 500, true )); SetInterval( ConfigMember->GetChildInt( "Parameters/PingInterval", 500, true ));
return true; return true;
} }