public bool Open(Iori iori)
{
ThingGraphContent source = null;
var sinkIo = ThingGraphIoManager.GetSinkIO(iori, IoMode.Read) as ThingGraphIo;
try {
// TODO: check if iori already in use
source = sinkIo.Open(iori);
OnProgress("", -1, -1);
AttachCurrent(source, iori.Name);
return(true);
} catch (Exception ex) {
Registry.Pooled <IExceptionHandler>()
.Catch(new Exception("Open failed: " + ex.Message, ex), MessageType.OK);
try {
if (source != null)
{
sinkIo.Close(source);
}
} catch { }
return(false);
}
}
protected override ThingGraphContent OpenInternal(Iori source)
{
var gateway = new Limaki.Data.db4o.Gateway();
try {
gateway.Open(source);
var sink = new ThingGraphContent {
Data = new ThingGraph(gateway),
Source = source,
ContentType = Db4oThingGraphSpot.Db4oThingGraphContentType,
};
return(sink);
} catch (DatabaseFileLockedException ex) {
throw;
} catch (Exception ex) {
if (ex.InnerException != null && ex.InnerException is DatabaseFileLockedException)
{
throw ex.InnerException;
}
else
{
var olderVersion = ProveIfOlderVersion(gateway);
if (olderVersion != null)
{
throw new NotSupportedException(olderVersion, ex);
}
else
{
throw;
}
}
}
}
public virtual void Close()
{
if (ThingGraphIo != null)
{
ThingGraphIo.Close(GraphContent);
this.GraphContent = null;
}
}
public void Close()
{
if (Current != null)
{
Close(Current);
Trace.WriteLine(string.Format("DataBase closed {0}", Iori.ToFileName()));
Current = null;
}
}
public void ImportRawSource()
{
Save();
Close(Data);
bool tryIt = true;
while (tryIt && MessageBoxShow("Open a new, non exisiting file", "RawImport", MessageBoxButtons.OkCancel) == DialogResult.Ok)
{
var fileDialog = new FileDialogMemento();
DefaultDialogValues(fileDialog, WriteFilter);
DefaultDialogValues(OpenFileDialog, ReadFilter);
if (FileDialogShow(fileDialog, true) == DialogResult.Ok)
{
var sinkFile = fileDialog.FileName;
fileDialog.ResetFileName();
if (File.Exists(sinkFile))
{
continue;
}
if (tryIt = MessageBoxShow("Open the file to import", "RawImport", MessageBoxButtons.OkCancel) == DialogResult.Ok)
{
if (FileDialogShow(OpenFileDialog, true) == DialogResult.Ok)
{
var sourceFile = OpenFileDialog.FileName;
if (!File.Exists(sourceFile))
{
MessageBoxShow("File does not exist", "RawImport", MessageBoxButtons.Ok);
break;
}
tryIt = false;
var sourceInfo = Iori.FromFileName(sourceFile);
var sinkIo = ThingGraphIoManager.GetSinkIO(Iori.FromFileName(sinkFile), IoMode.Write) as ThingGraphIo;
ThingGraphContent sink = null;
try {
sink = sinkIo.Open(Iori.FromFileName(sinkFile));
var repairer = Registry.Pooled <ThingGraphRepairPool>()
.Find(sourceInfo.Extension, IoMode.Read) as IPipe <Iori, IThingGraph>;
this.AttachProgress(repairer as IProgress);
repairer.Use(Iori.FromFileName(sourceFile), sink.Data);
} catch (Exception ex) {
Registry.Pooled <IExceptionHandler>()
.Catch(new Exception("Raw import failed: " + ex.Message, ex), MessageType.OK);
sinkIo.Close(sink);
File.Delete(sinkFile);
}
sinkIo.Close(sink);
MessageBoxShow("Import successfull", "RawImport", MessageBoxButtons.Ok);
this.Open(Iori.FromFileName(sinkFile));
OpenFileDialog.ResetFileName();
}
}
}
}
}
public override void Close(ThingGraphContent sink)
{
Flush(sink);
var graph = sink.Data as ThingGraph;
if (graph != null)
{
graph.Close();
}
}
public override Iori Use(ThingGraphContent source)
{
var result = base.Use(source);
var thingGraph = source.Data as ThingGraph;
if (thingGraph != null)
{
result = thingGraph.Gateway.Iori;
}
return(result);
}
public override void Flush(ThingGraphContent sink)
{
if (sink.Data != null)
{
var graph = sink.Data as ThingGraph;
if (graph != null)
{
graph.Flush();
}
}
}
public static Iori GetIori(IGraph <IThing, ILink> g)
{
var graphContent = new ThingGraphContent {
Data = g.UnWrapped() as IThingGraph
};
return(Registry.Pooled <ThingGraphIoPool> ()
.OfType <ThingGraphIo> ()
.Select(io => io.Use(graphContent))
.Where(i => i != null)
.FirstOrDefault());
}
public virtual ThingGraphContent Use(Iori source, ThingGraphContent sink)
{
var result = Open(source);
if (sink.Data == null)
{
return(result);
}
else
{
throw new NotImplementedException("Merging not implemented");
}
}
public bool IsUnsaved(ThingGraphContent data)
{
var sink = ThingGraphIoManager.GetSinkIO(data.ContentType, IoMode.None) as ThingGraphIo;
if (sink is MemoryThingGraphIo)
{
if (data.Data.Count > 0)
{
return(true);
}
}
return(false);
}
protected void Close(ThingGraphContent data)
{
if (data == null)
{
return;
}
var sinkIo = new ThingGraphIoManager {
}.GetSinkIO(data.ContentType, IoMode.Write) as ThingGraphIo;
if (sinkIo != null)
{
sinkIo.Close(data);
}
}
public bool AttachCurrent(ThingGraphContent source, string message)
{
Close(Data);
Data = source;
ThingGraphIn?.Invoke(source);
Mesh.ApplyBackGraph(source.Data);
DataBound?.Invoke();
DataPostProcess?.Invoke(message);
return(true);
}
protected void Close(ThingGraphContent data)
{
if (data == null)
{
return;
}
Mesh.RemoveBackGraph(data.Data);
Mesh.ClearDisplays();
var sink = ThingGraphIoManager.GetSinkIO(data.ContentType, IoMode.Write) as ThingGraphIo;
if (sink != null)
{
sink.Close(data);
ThingGraphClosed?.Invoke(data);
}
}
public virtual void Save(ThingGraphContent source, Iori sinkInfo)
{
if (source == null)
{
return;
}
using (var sink = new FileStream(sinkInfo.ToFileName(), FileMode.Create)) {
var serializer = new ThingXmlSerializer {
Graph = source.Data, Things = source.Data.Elements().ToList()
};
serializer.Write(sink);
sink.Flush();
sink.Close();
}
source.Source = sinkInfo;
}
public bool ImportFiles(IEnumerable <string> sourceFiles)
{
var result = true;
if (sourceFiles.Count() > 0)
{
var progressSaved = this.Progress;
var progressHandler = Registry.Pooled <IProgressHandler> ();
this.Progress = (m, i, max) => progressHandler.Write(m, i, max);
try {
foreach (var sourceFile in sourceFiles)
{
if (File.Exists(sourceFile))
{
progressHandler.Show("Importing file " + sourceFile);
var sourceIori = Iori.FromFileName(sourceFile);
var sourceIo = ThingGraphIoManager.GetSinkIO(sourceIori, IoMode.Read) as ThingGraphIo;
if (sourceIo != null)
{
ThingGraphContent source = null;
try {
source = sourceIo.Open(sourceIori);
new ThingGraphMerger {
Progress = this.Progress
}.Use(source.Data, Data.Data);
} catch (Exception ex) {
Registry.Pooled <IExceptionHandler> ()
.Catch(new Exception("Add file failed: " + ex.Message, ex), MessageType.OK);
result = false;
} finally {
sourceIo.Close(source);
}
}
}
}
Progress = null;
progressHandler.Close();
} finally {
Progress = progressSaved;
}
}
return(result);
}
public static ThingGraphContent GetContent(IGraph <IThing, ILink> g)
{
var graphContent = new ThingGraphContent {
Data = g.UnWrapped() as IThingGraph
};
var iog = Registry.Pooled <ThingGraphIoPool>()
.OfType <ThingGraphIo>()
//.Select(io => io.Use(graphContent))
.Where(io => io.Use(graphContent) != null)
.FirstOrDefault();
if (iog == null)
{
return(graphContent);
}
var iori = iog.Use(graphContent);
var ct = iog.Use(iori);
graphContent.Source = iori;
graphContent.ContentType = ct.ContentType;
return(graphContent);
}
public void Open()
{
if (Current != null)
{
Trace.WriteLine(string.Format("Provider already opened {0}", Current.Description));
var conn = Current.Data as IGatewayConnection;
if (conn != null)
{
Trace.WriteLine(string.Format("Connection already opened {0}/{1}", conn.Gateway.IsOpen, conn.Gateway.Iori.ToFileName()));
}
}
else
{
var ioManager = new ThingGraphIoManager {
};
var sinkIo = ioManager.GetSinkIO(Iori, IoMode.Read) as ThingGraphIo;
try {
var sink = sinkIo.Open(Iori);
if (sink != null)
{
Trace.WriteLine(string.Format("DataBase opened {0}", Iori.ToFileName()));
Current = sink;
var graph = new SchemaThingGraph(Current.Data);
PrepareGraph(graph);
_thingGraph = graph;
}
else
{
throw new Exception("Database not found: " + Iori.ToString());
}
} catch (Exception e) {
Trace.WriteLine(e.Message);
_thingGraph = new ThingGraph();
Trace.WriteLine(string.Format("Empty Graph created {0}", Iori.ToFileName()));
}
}
}
public virtual Iori Use(ThingGraphContent source)
{
// Close(source);
return(source.Source as Iori);
}
public abstract void Close(ThingGraphContent sink);
public abstract void Flush(ThingGraphContent sink);
public virtual Iori Use(ThingGraphContent source, Iori sink)
{
source.Source = sink;
// Close(source);
return(sink);
}
public override void Flush(ThingGraphContent sink)
{
}
public override void Close(ThingGraphContent sink)
{
}
public override void Close(ThingGraphContent sink)
{
var sinkIo = ThingGraphIoManager.GetSinkIO(sink.Source as Iori, IoMode.Write) as ThingGraphIo;
Close(sink);
}
public override void Flush(ThingGraphContent sink)
{
Save(sink, sink.Source as Iori);
}
