Important Update:

- ItemBufferCore:
  - New Class for storing items in a FIFO style buffer
- FunctionCore:
  - Implemented pulled input:
    - Function creates static output: StoredOutput & StoredOutputLen
    - Other Function pulls static output from input linked functions
- FunctionCore-ChannelBuffer:
  - Tried to create a processing buffer
  - Abandoned for now

FunctionCore-ChannelBuffer.h

@@ -0,0 +1,222 @@
+/*
+ * FunctionCore.h
+ *
+ *  Created on: 18 May 2016
+ *      Author: wentzelc
+ */
+
+#ifndef REDACORE_FUNCTIONCORE_H_
+#define REDACORE_FUNCTIONCORE_H_
+
+// Standard C/C++ Libraries
+/* none */
+
+// redA Libraries
+#include "LogCore.h"
+#include "DataTreeCore.h"
+#include "CharBufferCore.h"
+#include "ItemBufferCore.h"
+
+//---------------------------------------------------------------------------
+
+// Preview
+typedef struct SChannel         TChannel;
+typedef struct SChannelLink     TChannelLink;
+typedef struct SProcessBuffer   TProcessBuffer;
+typedef struct SProcessItem     TProcessItem;
+
+class CFunctionCore;
+
+//---------------------------------------------------------------------------
+
+struct SChannel
+{
+    char            * Name;
+
+    TChannelLink    * FirstInput;
+    TChannelLink    * FirstOutput;
+
+    bool            InputEnabled;
+    bool            OutputEnabled;
+
+    TProcessBuffer  * InputBuffer;
+
+    TChannel        * Next;
+};
+//---------------------------------------------------------------------------
+
+struct SChannelLink
+{
+    CFunctionCore   * Function;
+    char            * Name;
+
+    SChannelLink    * Next;
+};
+//---------------------------------------------------------------------------
+
+struct SProcessBuffer
+{
+    // Process buffer
+    char                * Name;                 // Name of buffer;
+    CItemBufferCore     Buffer;                 // Message buffer
+    unsigned long       LastRefNo;              // Last RefNo for item
+
+    // Input parameters
+    bool        PassthroughCallback;            // Send Callback once processed message has been passed on, else once processed
+
+    // Output parameters
+    TChannel    * OutputChannel;                // Channel to which to pass buffer output
+    bool        OutputCallback;                 // Expect callback on output?
+
+    TProcessBuffer      * Next;                 // Next buffer in list
+};
+//---------------------------------------------------------------------------
+
+struct SProcessItem
+{
+    // Input Parameters
+    TChannel        * SourceChannel;
+    char            * SourceRef;
+    bool            SourceCallback;
+
+    // Processing Parameters
+    bool            Processed;
+    bool            Completed;
+
+    // Output Parameters
+    timeval         CallbackTimer;
+    TChannelLink    FirstOutput;
+
+    // Input Data
+    void            * DataIn;
+    int             DataInLen;
+
+    // Output Data
+    void            * DataOut;
+    int             DateOutLen;
+};
+//---------------------------------------------------------------------------
+
+class CFunctionCore
+{
+protected:
+    // Function Definition
+    char    * Name;
+    char    * Type;
+
+    // Configuration
+    CDataTree   * DataTree;
+    TDataMember * ConfigMember;
+    TDataMember * LinkConfigMember;
+
+    // Channels
+    TChannel     * FirstChannel;
+
+    // Processing Queues
+    TProcessBuffer  * FirstProcessBuffer;
+
+    // Logging
+    CLogCore    * Log;
+    EDebugLevel LogLevel;
+    int         LogOutput;
+
+    // Stored Output
+    char        * StoredOutput;
+    int         StoredOutputLen;
+
+    // Manage Channel
+    inline TChannel *  GetChannel( const char * Name ) {
+        if (!Name) return NULL;
+        TChannel * Channel = FirstChannel;
+        while (Channel && strcmp( Name, Channel->Name ))
+            Channel = Channel->Next;
+        return Channel;
+    }
+
+    // Load configuration
+    virtual bool  LoadConfigData();
+    virtual bool  LoadChannelLinkData();
+
+    // Data Input/Output
+    virtual int  Output( const TChannel * Channel, const char * Data, int Len );
+    virtual bool PullInput( TChannel * Channel );
+
+    // Processing Queue
+    TProcessItem *  CreateProcessItem();
+
+public:
+    // Life cycle
+    CFunctionCore( const char * pName, const char * Type );
+    virtual ~CFunctionCore();
+
+    // Load Configuration
+    virtual bool  Init();
+
+    bool  InitConfig( const char * pConfigPath );
+    bool  InitConfig( TDataMember * pConfigMember );
+
+    bool  InitChannelLinks( const char * pLinkConfigPath );
+    bool  InitChannelLinks( TDataMember *pLinkConfigMember );
+
+    // Set Parameters Manually
+    bool  SetLogParam( EDebugLevel pDebugLevel, int pOutputDisplay );
+    bool  SetLogLevel( EDebugLevel pDebugLevel );
+
+    // Miscellaneous
+    inline const char * GetName()   { return Name; };
+    inline const char * GetType()   { return Type; };
+
+    // Manage Channels
+    virtual TChannel *  AddChannel( const char * ChannelName, const bool pInputEnable = true, const bool pOutputEnabled = true );
+    inline bool        SetChannelOutEnable( const char * ChannelName, const bool pOutputEnable ) {
+        TChannel * Channel = GetChannel( ChannelName );
+        if (!Channel) return false;
+        Channel->OutputEnabled = pOutputEnable;
+        return true;
+    }
+    inline bool        SetChannelInEnable( const char * ChannelName, const bool pInputEnable ) {
+        TChannel * Channel = GetChannel( ChannelName );
+        if (!Channel) return false;
+        Channel->InputEnabled = pInputEnable;
+        return true;
+    }
+    inline bool         isInputEnabled( const char * ChannelName ) {
+        TChannel * Channel = GetChannel( ChannelName );
+        return ((Channel)? Channel->InputEnabled : false);
+    }
+    inline bool         isOutputEnabled( const char * ChannelName ) {
+        TChannel * Channel = GetChannel( ChannelName );
+        return ((Channel)? Channel->OutputEnabled : false);
+    }
+
+    // Pushing Data Output -> Input
+    virtual int Output( const char * ChannelName, const char * Data, int Len = -1 );
+    virtual int Input( const char * ChannelName, const char * Data, int Len = -1 );
+
+    // Pulling Data Input <- Output
+    virtual bool PullInput( const char * ChannelName );
+    virtual bool PullOutput( const char * ChannelName, char ** Data, int * Len = NULL );
+
+    // Manages Process Buffers
+    TProcessBuffer * CreateProcessBuffer( const char * Name );
+    TProcessBuffer * GetProcessBuffer( const char * Name );
+
+    TProcessItem *  CreateProcessItem( const char * BufferName );
+    TProcessItem *  GetProcessItem( const char BufferName, const int Ref );
+    bool            DestroyProcessItem( const char * BufferName, const int Ref );
+
+    // Queued Output
+    virtual bool OutputMessage( TChannel * SourceChannel, const char * TargetChannelName, const int RefNo, bool Callback, const char * Data, int Len = -1 );
+    virtual bool OutputMessageCallback( TChannel * SourceChannel, const char * TargetChannelName, const int RefNo, const bool Success, const char * Error );
+    virtual bool InputMessage( TChannel * SourceChannel, const char * TargetChannelName, const int RefNo, bool Callback, const char * Data, int Len = -1 );
+    virtual bool InputMessageCancel( TChannel * SourceChannel, const char * TargetChannelName, const int RefNo );
+
+    // Automated Data Input/Output
+    virtual bool LinkInputChannel( const char * ChannelName, const char * OutFunctionName, const char * OutChannelName, bool Bidirectional );
+    virtual bool LinkOutputChannel( const char * ChannelName, const char * InFunctionName, const char * InChannelName, bool Bidirectional );
+    virtual bool Process() = 0;
+};
+
+//---------------------------------------------------------------------------
+
+#endif /* REDACORE_FUNCTIONCORE_H_ */