public void Execute(ProgressReporterEvent reporter)
{
if (_serialized == null)
{
throw new Exception("can't execute. No config!");
}
#region Instance Creator
var assembly = Assembly.LoadFrom(SystemVariables.ApplicationDirectory + @"\" + _serialized.NetworkCreatorAssembly);
if (assembly == null)
{
throw new Exception("Assembly not found: " + _serialized.NetworkCreatorAssembly);
}
var creator = assembly.CreateInstance(_serialized.NetworkCreatorType) as INetworkCreator;
if (creator == null)
{
throw new Exception("Type " + _serialized.NetworkCreatorType + " is not a network creator");
}
#endregion
#region Open Dataset
IFeatureDataset dataset = PlugInManager.Create(new Guid(_serialized.DatasetGuid)) as IFeatureDataset;
if (dataset == null)
{
throw new Exception("Unable to crete dataset");
}
dataset.ConnectionString = _serialized.ConnectionString;
dataset.Open();
this.FeatureDataset = dataset;
this.FeatureDatabase = dataset.Database as IFeatureDatabase3;
if (this.FeatureDatabase == null)
{
throw new Exception("Featuredatabase no implements IFeatureDatabase3");
}
#endregion
creator.NetworkName = _serialized.FeatureClasses.NetworkName;
creator.FeatureDataset = this.FeatureDataset;
creator.EdgeFeatureClasses = this.EdgeFeatureclasses;
creator.NodeFeatureClasses = this.NodeFeatureclasses;
creator.SnapTolerance = this.SnapTolerance;
creator.ComplexEdgeFcIds = this.ComplexEdgeFcIds;
creator.GraphWeights = this.GraphWeights;
creator.SwitchNodeFcIdAndFieldnames = this.SwitchNodeFcIds;
creator.NodeTypeFcIds = this.NetworkNodeTypeFcIds;
if (reporter != null && creator is IProgressReporter)
{
((IProgressReporter)creator).ReportProgress += (ProgressReport progressEventReport) =>
{
reporter(progressEventReport);
};
}
creator.Run();
}
static void Main(string[] args)
{
try
{
string assemblyName = String.Empty;
string instanceType = String.Empty;
string configFile = String.Empty;
for (int i = 0; i < args.Length - 1; i++)
{
if (args[i] == "-assembly")
{
assemblyName = args[++i];
}
if (args[i] == "-instance")
{
instanceType = args[++i];
}
if (args[i] == "-config")
{
configFile = args[++i];
}
}
if (String.IsNullOrWhiteSpace(assemblyName) || String.IsNullOrWhiteSpace(instanceType) || String.IsNullOrWhiteSpace(configFile))
{
Console.WriteLine("USAGE:");
Console.WriteLine("gView.Cmd.ExecuteSerializable -config <Config Filename>");
Console.WriteLine(" -assembly <assembly name>");
Console.WriteLine(" -instance <instance name>");
return;
}
var assembly = Assembly.LoadFrom(SystemVariables.ApplicationDirectory + @"\" + assemblyName);
var instance = assembly.CreateInstance(instanceType, true);
if (instance == null)
{
throw new Exception("Type not found: " + instanceType);
}
if (instance is Form)
{
((Form)instance).Show();
}
ProgressReporterEvent reportDelege = new ProgressReporterEvent(ReportProgress);
if (instance is ISerializableExecute)
{
((ISerializableExecute)instance).DeserializeObject(System.IO.File.ReadAllText(configFile));
((ISerializableExecute)instance).Execute(reportDelege);
Console.WriteLine();
Console.WriteLine("finished");
}
else
{
throw new Exception("Type " + instanceType + " do not implement ISerializableExecute");
}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex.Message);
Console.ResetColor();
}
}
override public List <IActivityData> Process()
{
#region Where Clauses
List <string> whereClauses = new List <string>();
if (_mergeField == null)
{
whereClauses.Add(String.Empty);
}
else
{
foreach (object val in _values)
{
if (val == null)
{
continue;
}
switch (_mergeField.type)
{
case FieldType.smallinteger:
case FieldType.integer:
case FieldType.biginteger:
whereClauses.Add(_mergeField.name + "=" + val.ToString());
break;
case FieldType.Float:
case FieldType.Double:
whereClauses.Add(_mergeField.name + "=" + Convert.ToDouble(val).ToString(_nhi));
break;
case FieldType.boolean:
whereClauses.Add(_mergeField.name + "=" + val.ToString());
break;
case FieldType.String:
whereClauses.Add(_mergeField.name + "='" + val.ToString() + "'");
break;
default:
throw new Exception("Can't merge this fieldtype: " + _mergeField.type.ToString());
}
}
}
#endregion
IDatasetElement sElement = base.SourceDatasetElement;
IFeatureClass sFc = base.SourceFeatureClass;
TargetDatasetElement tElement = base.TargetDatasetElement;
IDataset tDs = base.TargetDataset;
//IFeatureDatabase tDatabase = base.TargetFeatureDatabase;
Fields fields = new Fields();
if (_mergeField != null)
{
fields.Add(_mergeField);
}
IFeatureClass tFc = base.CreateTargetFeatureclass(sFc, fields);
IFeatureDatabase tDatabase = FeatureDatabase(tFc);
Report.featureMax = sFc.CountFeatures;
Report.featurePos = 0;
bool isPolygonFc = (sFc.GeometryType == geometryType.Polygon);
foreach (string whereClause in whereClauses)
{
ReportProgess("Query Filter: " + SourceData.FilterClause + (String.IsNullOrEmpty(whereClause) ? " AND " + whereClause : String.Empty));
Feature mergeFeature = null;;
bool attributeAdded = false;
using (IFeatureCursor cursor = SourceData.GetFeatures(whereClause))
{
IFeature feature;
List <IPolygon> polygons = new List <IPolygon>();
while ((feature = cursor.NextFeature) != null)
{
if (mergeFeature == null)
{
mergeFeature = new Feature();
}
Report.featurePos++;
if (!CancelTracker.Continue)
{
break;
}
if (_mergeField != null && attributeAdded == false)
{
mergeFeature.Fields.Add(new FieldValue(_mergeField.name, feature[_mergeField.name]));
attributeAdded = true;
}
if (isPolygonFc)
{
if (feature.Shape != null)
{
if (!(feature.Shape is IPolygon))
{
throw new Exception("Wrong argument type :" + feature.Shape.GeometryType.ToString());
}
polygons.Add(feature.Shape as IPolygon);
}
}
else
{
if (mergeFeature.Shape == null)
{
mergeFeature.Shape = feature.Shape;
}
else
{
mergeFeature.Shape = Algorithm.Merge(mergeFeature.Shape, feature.Shape, false);
}
}
ReportProgess();
}
if (isPolygonFc && mergeFeature != null)
{
ProgressReporterEvent r = new ProgressReporterEvent(MergePolygonReport);
mergeFeature.Shape = Algorithm.FastMergePolygon(polygons, CancelTracker, r);
}
}
if (mergeFeature != null)
{
if (!tDatabase.Insert(tFc, mergeFeature))
{
throw new Exception(tDatabase.lastErrorMsg);
}
}
if (!CancelTracker.Continue)
{
break;
}
}
ReportProgess("Flush Features");
base.FlushFeatureClass(tFc);
return(base.ToProcessResult(tFc));
}
public ProgressReporter()
{
ProgressChanged = new ProgressReporterEvent();
}
