/// <summary>
/// Calls PostRequest for the datasource, and which invokes the action
/// where all Adaptors connected start posting data back to the DataSource
///
/// If DataSource is IObserveable then this request is redirected directly to
/// the DataSource, otherwise it is redirected to central registry where all
/// information needed for this to happen' is collected
/// </summary>
public static void PostRequest(object aDataSource)
{
if (aDataSource == null)
{
return;
}
postQueue.Current = aDataSource;
if (postQueue.Current != aDataSource)
{
return;
}
if (aDataSource is IObserveable)
{
// If target is IObserveable then there's no need to enter it into the registry
// it can handle all on its own, so connection is made to him directly
(aDataSource as IObserveable).PostRequest();
}
else
{
// Since DataSource is a stupid object registry has to handle his bindings and connections
DataSourceInfo ds = (DataSourceInfo)GetInfoFor(aDataSource);
if (ds != null)
{
ds.PostRequest();
ds = null;
}
}
postQueue.Current = null;
if (postQueue.Current != null)
{
PostRequest(postQueue.Current);
}
}
/// <summary>
/// Usefull if one does want to provide caching method for geting updates and avoid discovery each time
/// </summary>
public static void GetRequestForInfo(DataSourceInfo aInfo)
{
if (aInfo == null)
{
return;
}
aInfo.GetRequest();
}
/// <summary>
/// Adds object to registry or connects events with Adaptor if object is
/// supporting interface IObserveable
///
/// If DataSource is IObserveable then it will be bypassing registry all the time
/// </summary>
public static bool Add(object aDataSource, IAdaptor aAdaptor, EApplyMethod aInstant)
{
if (aDataSource is IDataAdaptor)
{
return(Add((aDataSource as IDataAdaptor).FinalTarget, aAdaptor, aInstant));
}
if (aDataSource is IObserveable)
{
// If target is IObserveable then there's no need to enter it into the registry
// it can handle all on its own, so connection is made to him directly
if (aAdaptor.IsBoundaryAdaptor == false)
{
(aDataSource as IObserveable).PostRequested += aAdaptor.PostMethod;
(aDataSource as IObserveable).DataChanged += aAdaptor.AdapteeDataChanged;
}
else
{
(aDataSource as IObserveable).DataChanged += aAdaptor.BoundaryAdapteeDataChanged;
}
}
else
{
IObserveable ob = GetInfoFor(aDataSource);
if (ob != null)
{
DataSourceInfo ds = (DataSourceInfo)ob;
if (aAdaptor.IsBoundaryAdaptor == false)
{
ds.PostRequested += aAdaptor.PostMethod;
ds.DataChanged += aAdaptor.AdapteeDataChanged;
}
else
{
ds.DataChanged += aAdaptor.BoundaryAdapteeDataChanged;
}
// Count direct adaptors only, ignore indirect
if ((aAdaptor.Target is IAdaptor) == false)
{
ds.RefCount += 1;
}
ds = null;
return(true);
}
DataSourceInfo nds = new DataSourceInfo(aDataSource, aInstant);
if (aAdaptor.IsBoundaryAdaptor == false)
{
nds.PostRequested += aAdaptor.PostMethod;
nds.DataChanged += aAdaptor.AdapteeDataChanged;
}
else
{
nds.DataChanged += aAdaptor.BoundaryAdapteeDataChanged;
}
datasources.Add(nds);
nds = null;
}
return(true);
}
/// <summary>
/// Calls GetRequest for the datasource, and which invokes the action
/// where all Adaptors connected start posting data back to the DataSource
///
/// If DataSource is IObserveable then this request is redirected directly to
/// the DataSource, otherwise it is redirected to central registry where all
/// information needed for this to happen' is collected
/// </summary>
public static void GetRequest(object aDataSource)
{
if (aDataSource == null)
{
return;
}
getQueue.Current = aDataSource;
if (getQueue.Current != aDataSource)
{
return;
}
// Check if this is adaptor we're asking about
if (TypeValidator.IsCompatible(aDataSource.GetType(), typeof(Adaptor)) == true)
{
aDataSource = (aDataSource as Adaptor).FinalTarget;
if (aDataSource == null)
{
return;
}
}
if (aDataSource is IObserveable)
{
// If target is IObserveable then there's no need to enter it into the registry
// it can handle all on its own, so connection is made to him directly
(aDataSource as IObserveable).GetRequest();
}
else
{
// Since DataSource is a stupid object registry has to handle his bindings and connections
DataSourceInfo ds = (DataSourceInfo)GetInfoFor(aDataSource);
if (ds != null)
{
GetRequestForInfo(ds);
ds = null;
}
}
getQueue.Current = null;
if (getQueue.Current != null)
{
GetRequest(getQueue.Current);
}
}
/// <summary>
/// Threadsafe index get, just assign null as ReferenceTarget if you don't need specific Target
/// </summary>
public static IObserveable GetInfo(int aIdx, object aReferenceTarget)
{
if ((aIdx >= 0) && (aIdx < Count))
{
DataSourceInfo res = (DataSourceInfo)datasources[aIdx];
if (aReferenceTarget != null)
{
if (aReferenceTarget == res.Target)
{
return(res);
}
else
{
return(GetInfoFor(aReferenceTarget));
}
}
else
{
return(res);
}
}
return(null);
}
/// <summary>
/// Either removes object from central registry or disconnects Adaptor from the
/// DataSource if object is supporting interface IObserveable
///
/// If DataSource is IObserveable then it was bypassing registry all along
/// </summary>
public static void Remove(object aDataSource, IAdaptor aAdaptor)
{
int idx = 0;
bool found = false;
if (aDataSource is IDataAdaptor)
{
Remove((aDataSource as IDataAdaptor).FinalTarget, aAdaptor);
return;
}
if (aDataSource is IObserveable)
{
// If target is IObserveable then there's no need to enter it into the registry
// it can handle all on its own, so connection is made to him directly
if (aAdaptor != null)
{
if (aAdaptor.IsBoundaryAdaptor == false)
{
(aDataSource as IObserveable).PostRequested -= aAdaptor.PostMethod;
(aDataSource as IObserveable).DataChanged -= aAdaptor.AdapteeDataChanged;
}
else
{
(aDataSource as IObserveable).DataChanged -= aAdaptor.BoundaryAdapteeDataChanged;
}
}
}
else
{
foreach (DataSourceInfo ds in datasources)
{
if (ds.Target == aDataSource)
{
found = true;
break;
}
else
{
idx++;
}
}
if (found == true)
{
DataSourceInfo ds = (DataSourceInfo)datasources[idx];
// Count direct adaptors only, ignore indirect
if ((aAdaptor.Target is IAdaptor) == false)
{
ds.RefCount--;
}
if (ds != null)
{
if (ds.RefCount <= 0)
{
if (aAdaptor != null)
{
if (aAdaptor.IsBoundaryAdaptor == false)
{
ds.PostRequested -= aAdaptor.PostMethod;
ds.DataChanged -= aAdaptor.AdapteeDataChanged;
}
else
{
ds.DataChanged -= aAdaptor.BoundaryAdapteeDataChanged;
}
}
ds.Target = null;
datasources.RemoveAt(idx);
}
}
ds = null;
}
}
}
