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

59
ApplicationCore.cpp
View File

@@ -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 );
if ((TempMember = ConfigMember->GetMember( "Log/Output", true )))
{
TempMember = TempMember->GetFirstChild();
while (TempMember)
{
if (TempMember->Value)
if ((TempStr = (char*)TempMember->GetStr()))
{
if (!strcasecmp( TempMember->Value, "Normal"))
if (!strcasecmp( TempStr, "Normal"))
pLogOutput |= OUT_NORMAL;
else if (!strcasecmp( TempMember->Value, "Bin"))
else if (!strcasecmp( TempStr, "Bin"))
pLogOutput |= OUT_BIN;
else if (!strcasecmp( TempMember->Value, "Hex"))
else if (!strcasecmp( TempStr, "Hex"))
pLogOutput |= OUT_HEX;
else if (!strcasecmp( TempMember->Value, "Count"))
else if (!strcasecmp( TempStr, "Count"))
pLogOutput |= OUT_COUNT;
else if (!strcasecmp( TempMember->Value, "AsIs"))
else if (!strcasecmp( TempStr, "AsIs"))
pLogOutput |= OUT_ASIS;
else if (!strcasecmp( TempMember->Value, "CRLF"))
else if (!strcasecmp( TempStr, "CRLF"))
pLogOutput |= OUT_CRLF;
}
// Next
TempMember = DataTree->GetNextChild( TempMember );
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

8
ApplicationCore.h
View File

@@ -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;

486
DataTreeCore.cpp
View File

@@ -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;
CDataMember::~CDataMember()
{
// Remove from parent
if (Parent)
Parent->Len--;
if (this == Parent->LastChild) {
Parent->LastChild = PrevPeer;
}
PrevPeer->NextPeer = NextPeer;
NextPeer->PrevPeer = PrevPeer;
// Destroy value/children
Clear();
// 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 CDataTree::DestroyMember( TDataMember ** Member )
bool CDataMember::Clear()
{
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) );
if (Value) {
free( Value );
Value = NULL;
}
free( *Member );
// Restore list integrity
*Member = NextMember;
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 {

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
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;
};

65
FunctionCore.cpp
View File

@@ -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 );
if ((TempMember = ConfigMember->GetMember( "Log/Output", true )))
{
TempMember = TempMember->GetFirstChild();
while (TempMember)
{
if (TempMember->Value)
if ((TempStr = (char*)TempMember->GetStr()))
{
if (!strcasecmp( TempMember->Value, "Normal"))
if (!strcasecmp( TempStr, "Normal"))
pLogOutput |= OUT_NORMAL;
else if (!strcasecmp( TempMember->Value, "Bin"))
else if (!strcasecmp( TempStr, "Bin"))
pLogOutput |= OUT_BIN;
else if (!strcasecmp( TempMember->Value, "Hex"))
else if (!strcasecmp( TempStr, "Hex"))
pLogOutput |= OUT_HEX;
else if (!strcasecmp( TempMember->Value, "Count"))
else if (!strcasecmp( TempStr, "Count"))
pLogOutput |= OUT_COUNT;
else if (!strcasecmp( TempMember->Value, "AsIs"))
else if (!strcasecmp( TempStr, "AsIs"))
pLogOutput |= OUT_ASIS;
else if (!strcasecmp( TempMember->Value, "CRLF"))
else if (!strcasecmp( TempStr, "CRLF"))
pLogOutput |= OUT_CRLF;
}
// Next
TempMember = DataTree->GetNextChild( TempMember );
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))

10
FunctionCore.h
View File

@@ -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 );

73
JSONparseCore.cpp
View File

@@ -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) {

16
JSONparseCore.h
View File

@@ -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

88
SelectableCore.cpp
View File

@@ -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;

2
WatchdogCore.cpp
View File

@@ -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;
}