public ValueTask <SerializableClassifiedSpans> GetClassificationsAsync(
PinnedSolutionInfo solutionInfo,
DocumentId documentId,
TextSpan span,
ClassificationType type,
ClassificationOptions options,
StorageDatabase database,
bool isFullyLoaded,
CancellationToken cancellationToken)
{
return(RunServiceAsync(async cancellationToken =>
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var document = solution.GetDocument(documentId) ?? await solution.GetSourceGeneratedDocumentAsync(documentId, cancellationToken).ConfigureAwait(false);
Contract.ThrowIfNull(document);
using var _ = ArrayBuilder <ClassifiedSpan> .GetInstance(out var temp);
await AbstractClassificationService.AddClassificationsInCurrentProcessAsync(
document, span, type, options, temp, cancellationToken).ConfigureAwait(false);
if (isFullyLoaded)
{
// Once fully loaded, there's no need for us to keep around any of the data we cached in-memory
// during the time the solution was loading.
lock (_cachedData)
_cachedData.Clear();
// Enqueue this document into our work queue to fully classify and cache.
_workQueue.AddWork((document, type, options, database));
}
return SerializableClassifiedSpans.Dehydrate(temp.ToImmutable());
}, cancellationToken));
}
public static IMetric[] ParseMetrics(
Dataset dataset,
Array <string> metricsNames,
ClassificationType classificationType
)
{
if (metricsNames.IsEmpty)
{
throw new ArgumentException(nameof(metricsNames) + " can't be empty.");
}
var metrics = new IMetric[metricsNames.Length];
for (int i = 0; i < metricsNames.Length; i++)
{
var currentMetricName = metricsNames[i];
metrics[i] = (metricsNames[i], classificationType) switch
{
("fscore", ClassificationType.SingleLabel) => new SingleLabelFScore(dataset),
("fscore", ClassificationType.MultiLabel) => new MultiLabelFScore(dataset),
("average-rule-volume", _) => new AverageRuleVolume(dataset),
("rule-count", _) => new RuleCount(),
("model-size", _) => new ModelSize(),
_ => throw new ArgumentException($"Unsupported (Metric, ClassificationType): ({currentMetricName}, {classificationType})."),
};
}
public override bool Execute(CommandActivity commandActivity)
{
try
{
var hostObject = (Incoming)commandActivity.WorkItem;
if (hostObject.BaseFile != null)
{
return(true);
}
//Get tartet file
var echDocument = hostObject.FileContentHierarchyFlat.OfType <Document>()
.First(d => d.Type == ClassificationType.GetObject(Rubicon.Gever.Bund.EGovInterface.Domain
.WellKnownObjects.DocumentClassification.EchImport.GetObjectID()));
var targetFile = ImportHelper.TenantKnowsObject(echDocument);
if (targetFile == null)
{
throw new ActivityCommandException("").WithUserMessage(LocalizedUserMessages.FileNotImported
.ToLocalizedName()
.FormatWith(commandActivity));
}
hostObject.Insert(targetFile);
}
catch (Exception ex)
{
s_logger.Error(ex.Message, ex);
throw;
}
return(true);
}
/// <summary>
/// Creates a ClassificationType.
/// </summary>
/// <param name="classificationScheme">The classification scheme.</param>
/// <param name="classifiedObject">The classified object UUID.</param>
/// <param name="nodeRepresentation">The node representation.</param>
/// <param name="slots">The SlotType1 entries in the classification.</param>
/// <param name="name">The name of the classiciation.</param>
/// <returns>ClassificationType.</returns>
internal ClassificationType CreateClassificationType(
string id,
string classificationScheme,
string classifiedObject,
string nodeRepresentation,
List <SlotType1> slots,
InternationalStringType name)
{
var classification = new ClassificationType();
classification.classificationScheme = classificationScheme;
classification.classifiedObject = classifiedObject;
classification.nodeRepresentation = nodeRepresentation;
classification.objectType = XDS_CLASSIFICATION;
classification.id = id;
if (slots != null && slots.Count > 0)
{
classification.Slot = slots.ToArray();
}
if (name != null)
{
classification.Name = name;
}
return(classification);
}
public VCard ExportVCard(ClassificationType classificationType)
{
return(new VCard
{
Version = VCardVersion.V4,
FirstName = FirstName,
LastName = LastName,
FormattedName = FullName,
Organization = OrganisationName,
Classification = classificationType,
Note = Notes,
Url = new Uri(WebsiteUrl),
Kind = Kind.Individual,
Categories = Categories.ToDtos().ToArray(),
CustomExtensions = CustomFields?
.Select(x => new CustomExtension
{
Key = x.Key,
Value = x.Value
}
).ToArray(),
Telephones = Phones?
.Select(x => new Telephone
{
Number = x.PhoneNo,
Type = x.Type switch
{
PhoneType.Home => TelephoneType.Home,
PhoneType.Mobile => TelephoneType.Cell,
PhoneType.Work => TelephoneType.Work,
_ => throw new InvalidDataException($"Invalid Phone Type")
}
}).ToArray(),
private Dto.Xsd.IncomeClassificationType MapIncomeClassificationType(ClassificationType classificationType)
{
switch (classificationType)
{
case ClassificationType.RetailSalesOfGoodsAndServicesPrivateClientele:
return(Dto.Xsd.IncomeClassificationType.RetailSalesOfGoodsAndServicesPrivateClientele);
case ClassificationType.OtherSalesOfGoodsAndServices:
return(Dto.Xsd.IncomeClassificationType.OtherSalesOfGoodsAndServices);
case ClassificationType.OtherOrdinaryIncome:
return(Dto.Xsd.IncomeClassificationType.OtherOrdinaryIncome);
case ClassificationType.CreditExchangeDifferences:
return(Dto.Xsd.IncomeClassificationType.CreditExchangeDifferences);
case ClassificationType.IntraCommunityForeignSalesOfGoodsAndServices:
return(Dto.Xsd.IncomeClassificationType.IntraCommunityForeignSalesOfGoodsAndServices);
case ClassificationType.ThirdCountryForeignSalesOfGoodsAndServices:
return(Dto.Xsd.IncomeClassificationType.ThirdCountryForeignSalesOfGoodsAndServices);
default:
throw new ArgumentException($"Cannot map ClassificationType {classificationType} to {nameof(Dto.Xsd.IncomeClassificationType)}.");
}
}
private static async Task <bool> TryGetCachedClassificationsAsync(
Document document,
TextSpan textSpan,
ClassificationType type,
RemoteHostClient client,
bool isFullyLoaded,
ArrayBuilder <ClassifiedSpan> result,
CancellationToken cancellationToken)
{
// Only try to get cached classifications if we're not fully loaded yet.
if (isFullyLoaded)
{
return(false);
}
var(documentKey, checksum) = await SemanticClassificationCacheUtilities.GetDocumentKeyAndChecksumAsync(
document, cancellationToken).ConfigureAwait(false);
var cachedSpans = await client.TryInvokeAsync <IRemoteSemanticClassificationService, SerializableClassifiedSpans?>(
document.Project,
(service, solutionInfo, cancellationToken) => service.GetCachedClassificationsAsync(
documentKey, textSpan, type, checksum, cancellationToken),
cancellationToken).ConfigureAwait(false);
// if the remote call fails do nothing (error has already been reported)
if (!cachedSpans.HasValue || cachedSpans.Value == null)
{
return(false);
}
cachedSpans.Value.Rehydrate(result);
return(true);
}
public RootNodeType MapFrom(ClassificationType classificationType)
{
switch (classificationType)
{
case ClassificationType.ObservedData:
return(RootNodeTypes.ObservedDataFolder);
case ClassificationType.Simulation:
return(RootNodeTypes.SimulationFolder);
case ClassificationType.Comparison:
return(RootNodeTypes.ComparisonFolder);
case ClassificationType.ParameterIdentification:
return(RootNodeTypes.ParameterIdentificationFolder);
case ClassificationType.SensitiviyAnalysis:
return(RootNodeTypes.SensitivityAnalysisFolder);
case ClassificationType.QualificationPlan:
return(RootNodeTypes.QualificationPlanFolder);
default:
throw new ArgumentOutOfRangeException(nameof(classificationType));
}
}
/// <summary>
/// Creates an classification type.
/// </summary>
/// <param name="classificationScheme">The classification scheme.</param>
/// <param name="nodeRepresentation">The node representation.</param>
/// <param name="name">The name.</param>
/// <param name="slots">The slots.</param>
/// <returns>Returns the created classification type.</returns>
public static ClassificationType CreateClassification(XdsGuidType classificationScheme, string nodeRepresentation, string name, params SlotType1[] slots)
{
var retVal = new ClassificationType()
{
id = $"urn:uuid:{Guid.NewGuid().ToString()}",
classificationScheme = classificationScheme.ToString(),
nodeRepresentation = nodeRepresentation
};
if (name != null)
{
retVal.Name = new InternationalStringType()
{
LocalizedString = new LocalizedStringType[] {
new LocalizedStringType()
{
value = name
}
}
};
}
// Slots
retVal.Slot = slots;
return(retVal);
}
public static void SendPacket(byte[] msgBytes, out ClassificationType classificationType,
out ushort TCPNumber, out ushort originator, out byte TTL, /*out ushort pathLength,*/ out ushort payloadLength)
{
var idx = 1; // Start at 1 since we've already checked the message ID
classificationType = (ClassificationType)msgBytes[idx];
idx += 1;
TCPNumber = BitConverter.ToUInt16(msgBytes, idx);
idx += sizeof(ushort);
originator = BitConverter.ToUInt16(msgBytes, idx);
idx += sizeof(ushort);
TTL = msgBytes[idx];
idx += 1;
/*
* pathLength = BitConverter.ToUInt16(msgBytes, idx);
* idx += sizeof(ushort);
*
* ushort[] path = new ushort[pathLength];
* int i;
* for(i = 0; i < pathLength; i = i + 1){
* path[i] = BitConverter.ToUInt16(msgBytes, idx);
* idx += sizeof(ushort);
* }
*/
payloadLength = BitConverter.ToUInt16(msgBytes, idx);
idx += sizeof(ushort);
//return path;
}
private void DrawSourceLines()
{
lineWidth = Math.Ceiling(canvas.RenderSize.Height / RowCount);
if (lineWidth < 1)
{
lineWidth = 1;
}
if (LeftSourceCode == null && RightSourceCode == null)
{
return;
}
for (int i = 0; i < RowCount; i++)
{
ClassificationType lineType = GetLineDiffClassificationType(i);
if (lineType == ClassificationType.NotModifiedLine || lineType == ClassificationType.ImaginaryLine)
{
// There is no difference in this line or the line is imaginary, so nothing needs to be drawn.
continue;
}
var myLine = new Line();
double lineYCoordinates = GetLineHorisontalCoordinates(i);
myLine.Stroke = new SolidColorBrush(DiffBackgroundRenderer.GetColorFromClassificationType(lineType));
myLine.X1 = 0;
myLine.X2 = canvas.RenderSize.Width;
myLine.Y1 = lineYCoordinates;
myLine.Y2 = lineYCoordinates;
myLine.UseLayoutRounding = true;
myLine.StrokeThickness = lineWidth;
canvas.Children.Add(myLine);
}
}
/// <summary>
/// Compose a detection message
/// </summary>
/// <param name="msgBytes"></param>
/// <param name="originator"></param>
/// <param name="classificatonType"></param>
/// <param name="detectionNum"></param>
/// <returns></returns>
public static int Detection(byte[] msgBytes, ushort originator, ClassificationType classificatonType,
int detectionNum, byte TTL)
{
var idx = 0;
// Detection message type
msgBytes[idx] = (byte)MessageIds.Detect;
idx++;
// Classification
msgBytes[idx] = (byte)classificatonType;
idx++;
// Detection message number
var detectNum = (ushort)Math.Min(detectionNum, ushort.MaxValue);
BitConverter.InsertValueIntoArray(msgBytes, idx, detectNum);
idx += sizeof(ushort);
// Message originator
BitConverter.InsertValueIntoArray(msgBytes, idx, originator);
idx += sizeof(ushort);
// TTL
msgBytes[idx] = (byte)TTL;
idx++;
// Check if message is the right size
if (idx != DetectionMessageSize)
{
throw new Exception("Compose Detection: message composed is " + idx + " bytes; should be " + DetectionMessageSize);
}
return(idx);
}
public void SetClassification(int cellX, int cellY, ClassificationType type)
{
if (this._classification != null)
{
_classification[cellX, cellY] = (int)type;
}
}
/// <summary>
/// Creates an classification type.
/// </summary>
/// <param name="classifiedObject">The classified object.</param>
/// <param name="scheme">The scheme.</param>
/// <param name="nodeRepresentation">The node representation.</param>
/// <param name="name">The name.</param>
/// <param name="slots">The slots.</param>
/// <returns>Returns the created classification type.</returns>
public static ClassificationType CreateClassification(RegistryObjectType classifiedObject, XdsGuidType scheme, string nodeRepresentation, string name, params SlotType1[] slots)
{
var retClass = new ClassificationType
{
id = $"urn:uuid:{Guid.NewGuid().ToString()}",
classificationScheme = scheme.ToString(),
classifiedObject = classifiedObject.id,
nodeRepresentation = nodeRepresentation,
Slot = slots
};
if (name != null)
{
retClass.Name = new InternationalStringType()
{
LocalizedString = new LocalizedStringType[] {
new LocalizedStringType()
{
value = name
}
}
};
}
return(retClass);
}
private static ILabel[] ReadLabelFile(string filename, ClassificationType classificationType)
{
return(classificationType switch
{
ClassificationType.SingleLabel => throw new NotImplementedException(),
ClassificationType.MultiLabel => ReadMultiLabelFile(filename),
_ => throw CommonExceptions.UnknownClassificationType,
});
private static ClassificationType CreateClassificationType()
{
ClassificationType c = new ClassificationType();
c.Description = "Omschrijving";
c.Id = CreateEntityIdType();
return(c);
}
public LasPoint2Long(byte bitsField, ClassificationType classification, ushort intensity, ushort pointSourceId,
sbyte scanAngleRank, byte userData, int x, int y, int z, ushort red, ushort green, ushort blue)
: base(bitsField, classification, intensity, pointSourceId, scanAngleRank, userData, x, y, z)
{
_red = red;
_green = green;
_blue = blue;
}
static ILabel ComputeDefaultLabel(Array <ILabel> labels, ClassificationType classificationType)
{
return(classificationType switch
{
ClassificationType.SingleLabel => ComputeMajorityClass(labels),
ClassificationType.MultiLabel => ComputeAverageLabels(labels),
_ => throw CommonExceptions.UnknownClassificationType,
});
public LasPoint2Short(ClassificationType classification, ushort intensity, ushort pointSourceId, int x,
int y, int z, ushort red, ushort green, ushort blue)
: base(classification, intensity, pointSourceId, x, y, z)
{
_red = red;
_green = green;
_blue = blue;
}
private RootNode createRootNode(RootNodeType rootNodeType, ClassificationType classificationType)
{
var node = new RootNode(rootNodeType);
A.CallTo(() => _rootNodeTypeMapper.MapFrom(classificationType)).Returns(rootNodeType);
A.CallTo(() => _explorerPresenter.NodeByType(rootNodeType)).Returns(node);
return(node);
}
protected LasPointLong(byte bitsField, ClassificationType classification, ushort intensity,
ushort pointSourceId,
sbyte scanAngleRank, byte userData, int x, int y, int z)
: base(classification, intensity, pointSourceId, x, y, z)
{
_bitsField = new BitsField(bitsField);
_scanAngleRank = scanAngleRank;
_userData = userData;
}
public RootNodeType(string name, ApplicationIcon icon, ClassificationType classificationType = ClassificationType.Unknown)
{
Id = ShortGuid.NewGuid().ToString();
Name = name;
Icon = icon;
_classification = new Classification {
ClassificationType = classificationType
};
}
private static string getValueFromName(ClassificationType ct)
{
string rv = "";
if (ct.Name != null && ct.Name.LocalizedString.Length > 0)
{
rv = ct.Name.LocalizedString[0].value;
}
return(rv);
}
public LasPoint(ClassificationType classification, ushort intensity, ushort pointSourceId,
int x, int y, int z)
{
_classification = (byte)classification;
_intensity = intensity;
_pointSourceId = pointSourceId;
_x = x;
_y = y;
_z = z;
}
public static string ContinuousToClassifiedMRR(string strInFilePath, string strOutFilePath)
{
const ClassificationType outClassType = ClassificationType.Classified;
UndefinedClassInfo undefinedClassInfo = new UndefinedClassInfo();
undefinedClassInfo.SetNullForUndefinedRange = false;
undefinedClassInfo.UndefinedClassColor = Color.FromArgb(0, 128, 64, 0);
undefinedClassInfo.UndefinedClassLabel = "Undefined";
undefinedClassInfo.UndefinedValue = -9999;
ClassInfo[] newClassInfo = new ClassInfo[5];
//Initalize class items
for (int i = 0; i < newClassInfo.Length; i++)
{
newClassInfo[i] = new ClassInfo();
}
//Set classify ranges
newClassInfo[0].LowerBound = 0.0f;
newClassInfo[0].UpperBound = 4.0f;
newClassInfo[1].LowerBound = 4.0f;
newClassInfo[1].UpperBound = 8.0f;
newClassInfo[2].LowerBound = 8.0f;
newClassInfo[2].UpperBound = 12.0f;
newClassInfo[3].LowerBound = 12.0f;
newClassInfo[3].UpperBound = 16.0f;
newClassInfo[4].LowerBound = 16.0f;
newClassInfo[4].UpperBound = 20.0f;
//Set new class values
newClassInfo[0].NewValue = 4.0f;
newClassInfo[1].NewValue = 8.0f;
newClassInfo[2].NewValue = 12.0f;
newClassInfo[3].NewValue = 16.0f;
newClassInfo[4].NewValue = 20.0f;
//Set new class names
newClassInfo[0].NewLabel = "0 - 4";
newClassInfo[1].NewLabel = "4 - 8";
newClassInfo[2].NewLabel = "8 - 12";
newClassInfo[3].NewLabel = "12 -16";
newClassInfo[4].NewLabel = "16 - 20";
//Set new class color
newClassInfo[0].NewColor = Color.FromArgb(0, 0, 255, 255); //cyan
newClassInfo[1].NewColor = Color.FromArgb(0, 255, 128, 192); //Pink Color
newClassInfo[2].NewColor = Color.FromArgb(0, 255, 128, 64); //Orange
newClassInfo[3].NewColor = Color.FromArgb(0, 128, 0, 255);
newClassInfo[4].NewColor = Color.FromArgb(0, 255, 0, 0);
RasterAnalysis.ClassifyRaster(strInFilePath, strOutFilePath, "MI_MRR", outClassType, newClassInfo, undefinedClassInfo);
return(strOutFilePath);
}
public ItemEntry(String name, String type, ClassificationType classification, UInt16 width, UInt16 height, Boolean stackable, Boolean usable, Boolean throwable)
{
Name = name;
Type = type;
Classification = classification;
Width = width;
Height = height;
Stackable = stackable;
Usable = usable;
Throwable = throwable;
}
public ItemEntry(ItemName name, string type, ClassificationType classification, ushort width, ushort height, bool stackable, bool usable, bool throwable)
{
Name = name;
Type = type;
Classification = classification;
Width = width;
Height = height;
Stackable = stackable;
Usable = usable;
Throwable = throwable;
}
/// <summary>
/// Creates an node classification type.
/// </summary>
/// <param name="registryObject">The registry object.</param>
/// <param name="classificationNode">The classification node.</param>
/// <returns>Returns the created node classification type.</returns>
public static ClassificationType CreateNodeClassification(RegistryObjectType registryObject, XdsGuidType classificationNode)
{
var retClass = new ClassificationType
{
id = $"urn:uuid:{Guid.NewGuid()}",
classificationNode = classificationNode.ToString(),
classifiedObject = registryObject.id
};
return(retClass);
}
protected AbstractSemanticOrEmbeddedClassificationViewTaggerProvider(
IThreadingContext threadingContext,
ClassificationTypeMap typeMap,
IGlobalOptionService globalOptions,
IAsynchronousOperationListenerProvider listenerProvider,
ClassificationType type)
: base(threadingContext, globalOptions, listenerProvider.GetListener(FeatureAttribute.Classification))
{
_typeMap = typeMap;
_globalOptions = globalOptions;
_type = type;
}
public Matrix(string imagePath, int cols, int rows, Dictionary <string, Dictionary <string, double> > gridData)
{
this.GridData = gridData;
this.ImagePath = imagePath;
this.Cols = cols;
this.Rows = rows;
this.Type = ClassificationType.SELF;
InitializeComponent();
PostInit();
Classify();
BuildGrid();
BuildTree();
}
static XamlSyntaxHighlightingHelper()
{
XamlAttribute = new ClassificationType("xamlAttribute");
XamlElement = new ClassificationType("xamlElement");
XamlComment = new ClassificationType("xamlComment");
XamlTag = new ClassificationType("xamlTag");
XamlString = new ClassificationType("xamlString");
XamlContent = new ClassificationType("xamlContent");
XamlAttributeFormatDefinition = new TextFormatDefinition(new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0x00, 0x4E)));
XamlElementFormatDefinition = new TextFormatDefinition(new SolidColorBrush(Color.FromArgb(0xFF, 0xA3, 0x15, 0x15)));
XamlCommentFormatDefinition = new TextFormatDefinition(new SolidColorBrush(Color.FromArgb(0xFF, 0x53, 0x7D, 0x01)));
XamlContentFormatDefinition = new TextFormatDefinition(new SolidColorBrush(Color.FromArgb(0xFF, 0x01, 0x60, 0xE5)));
XamlStringFormatDefinition = new TextFormatDefinition(new SolidColorBrush(Color.FromArgb(0xFF, 0x01, 0x60, 0xE5)));
XamlTagFormatDefinition = new TextFormatDefinition(new SolidColorBrush(Color.FromArgb(0xFF, 0x01, 0x60, 0xE5)));
}
public Cluster(IndivData p, ClassificationType t)
{
switch (t)
{
case ClassificationType.Hierar:
AddHierar(p);
break;
case ClassificationType.KMeans:
AddKMeans(p);
break;
case ClassificationType.Utility:
AddUtility(p);
break;
default:
break;
}
}
/// <summary>
/// Do the classification for a <paramref name="fileToClassify"/>.
/// </summary>
/// <returns>Task that represents the classification process.</returns>
/// <param name="targetDirectory">The directory where files will be classified.</param>
/// <param name="fileToClassify">The file to classify.</param>
/// <param name="actionType">Specify action to classify media files.</param>
/// <param name="hierarchy">Hierarchy of classification.</param>
public async Task ClassifiyFileAsync(string targetDirectory, string fileToClassify, ActionType actionType, ClassificationType[] hierarchy)
{
ClassifiableFile classifiable = await GetClassifiableFromFileAsync(fileToClassify, hierarchy);
string classificationDirectory = GetClassificationDirectory(targetDirectory, classifiable, hierarchy);
_directory.CreateDirectory(classificationDirectory);
string targetFile = _path.Combine(classificationDirectory, _path.GetFileName(fileToClassify));
switch(actionType)
{
case ActionType.Copy:
_file.Copy(fileToClassify, targetFile, true);
break;
case ActionType.Move:
if (_file.Exists(targetFile))
{
if (_fileSystemHelper.IsSymbolicLink(targetFile))
{
_file.Delete(targetFile);
_file.Move(fileToClassify, targetFile);
}
else
{
_file.Delete(fileToClassify);
}
}
else
{
_file.Move(fileToClassify, targetFile);
}
break;
case ActionType.Link:
_fileSystemHelper.CreateSymbolicLink(fileToClassify, _path.Combine(classificationDirectory, _path.GetFileName(fileToClassify)));
break;
}
}
/// <summary>
/// Gets the classification directory.
/// </summary>
/// <returns>The classification directory.</returns>
/// <param name="classifiable">Classifiable.</param>
/// <param name="hierarchy">Hierarchy of classification.</param>
private string GetClassificationDirectory(string targetDirectory, ClassifiableFile classifiable, ClassificationType[] hierarchy)
{
string directory = targetDirectory;
foreach (var currentOrder in hierarchy)
{
switch (currentOrder)
{
case ClassificationType.Year:
directory = _path.Combine(directory, classifiable.DateTaken.Year.ToString());
break;
case ClassificationType.Month:
directory = _path.Combine(directory, classifiable.DateTaken.Month.ToString());
break;
case ClassificationType.Day:
directory = _path.Combine(directory, classifiable.DateTaken.Day.ToString());
break;
case ClassificationType.Hour:
directory = _path.Combine(directory, classifiable.DateTaken.Hour.ToString());
break;
case ClassificationType.Minute:
directory = _path.Combine(directory, classifiable.DateTaken.Minute.ToString());
break;
case ClassificationType.Second:
directory = _path.Combine(directory, classifiable.DateTaken.Second.ToString());
break;
case ClassificationType.Country:
directory = _path.Combine(directory,
(classifiable.Location != null && !string.IsNullOrWhiteSpace(classifiable.Location.Country)) ? classifiable.Location.Country : "Unknown country".T());
break;
case ClassificationType.State:
directory = _path.Combine(directory,
(classifiable.Location != null && !string.IsNullOrWhiteSpace(classifiable.Location.State)) ? classifiable.Location.State : "Unknown state".T());
break;
case ClassificationType.AdministrativeArea:
directory = _path.Combine(directory,
(classifiable.Location != null && !string.IsNullOrWhiteSpace(classifiable.Location.AdministrativeArea)) ? classifiable.Location.AdministrativeArea : "Unknown administrative area".T());
break;
case ClassificationType.Locality:
directory = _path.Combine(directory,
(classifiable.Location != null && !string.IsNullOrWhiteSpace(classifiable.Location.Locality)) ? classifiable.Location.Locality : "Unknown locality".T());
break;
case ClassificationType.Route:
directory = _path.Combine(directory,
(classifiable.Location != null && !string.IsNullOrWhiteSpace(classifiable.Location.Route)) ? classifiable.Location.Route : "Unknown route".T());
break;
case ClassificationType.MediaType:
directory = _path.Combine(directory, classifiable.MediaType.ToString());
break;
}
}
return directory;
}
/// <summary>
/// Creates a new XDS.b Classification object
/// </summary>
/// <param name="cScheme">Classification Scheme</param>
/// <param name="cObject">Classification Object</param>
/// <param name="cNode">Classification Node</param>
/// <param name="nRepr">Classification Representation</param>
/// <param name="name">Classification Name</param>
/// <param name="slots">Classification Slots</param>
/// <returns>The new XDS Classification object.</returns>
public static ClassificationType CreateClassification(string cScheme, string cObject, string cNode, string nRepr, string id, string name, SlotType[] slots)
{
ClassificationType c = new ClassificationType(cScheme, cObject, cNode, nRepr, id, name, slots);
return c;
}
protected override void OnTokenKindChanged()
{
switch (this.Kind)
{
case TokenKind.WhiteSpace:
ClassificationType = ClassificationTypes.WhiteSpace;
break;
case TokenKind.KeyWord:
ClassificationType = ClassificationTypes.Keyword;
break;
case TokenKind.Literal:
ClassificationType = ClassificationTypes.Literal;
break;
case TokenKind.Reference:
ClassificationType = ClassificationTypes.Identifier;
break;
case TokenKind.Error:
ClassificationType = ClassificationTypes.Literal;
break;
case TokenKind.MailSenderLink:
ClassificationType = JDClassificationTypes.MailLink;
break;
case TokenKind.JDUpdateLinkButton:
ClassificationType = JDClassificationTypes.UpdateJdLink;
break;
case TokenKind.JDUpdateText:
ClassificationType = JDClassificationTypes.UpdateJdText;
break;
case TokenKind.Text:
ClassificationType = JDClassificationTypes.Text;
break;
case TokenKind.NotResolvedReference:
ClassificationType = JDClassificationTypes.NotResolvedReference;
break;
case TokenKind.DocumentationTag:
ClassificationType = JDClassificationTypes.DocumentationTag;
break;
case TokenKind.Comment:
ClassificationType = ClassificationTypes.Comment;
break;
case TokenKind.XmlAttribute:
ClassificationType = JDClassificationTypes.XmlAttribute;
break;
case TokenKind.FakeReference:
ClassificationType = JDClassificationTypes.FakeIdentifier;
break;
case TokenKind.NewLine:
ClassificationType = JDClassificationTypes.Text;
break;
default:
ClassificationType = ClassificationTypes.StringLiteral;
break;
}
}
