public SqlWriter(Notation notation)
{
ProviderHelper = new DataProviderHelper();
this.notation = notation;
sb = new StringBuilder();
newLineFlag = false;
}
public Consolery(Type targetType, object target, string[] args, IMessenger messenger, Notation notationType)
{
Contract.Requires(targetType != null);
Contract.Requires(args != null);
Contract.Requires(messenger != null);
_target = target;
_targetType = targetType;
_args = args;
_messenger = messenger;
_actionMethods = _targetType
.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance)
.Where(method => method.GetCustomAttributes(false).OfType<ActionAttribute>().Any())
.ToList();
_metadata = new Metadata(_actionMethods);
_metadataValidator = new MetadataValidator(_targetType, _actionMethods, _metadata);
if (notationType == Notation.Windows)
{
_notation = new WindowsNotationStrategy(_args, _messenger, _metadata, _targetType, _actionMethods);
}
else
{
_notation = new LinuxNotationStrategy(_args, _messenger, _metadata);
}
}
/// <summary>
/// Default Application Constructor
/// </summary>
public MainWindow()
{
InitializeComponent();
GridStack = new Stack<Grid>();
TokenStack = new Stack<String>();
Token_Counter = 0;
OperatorPopCounter = 0;
AnimationSpeed = 1;
CurrentlyAnimating = false;
notation = Notation.Postfix;
StackSize = (int)StackCanvas.Height/RECTANGLE_HEIGHT;
}
private void ProcessQueryExp(Notation notation, Symbol qexpr, QueryContext context)
{
Notation.Record[] recs = notation.Select(qexpr,
new Descriptor[] { Descriptor.Union, Descriptor.Except }, 2);
if (recs.Length > 0)
{
ProcessQueryExp(notation, recs[0].Arg0, context);
ProcessQueryTerm(notation, recs[0].Arg1, context);
}
else
ProcessQueryTerm(notation, qexpr, context);
ConfirmBindings(notation, qexpr, context);
}
/// <summary>
/// Runs an appropriate Action method
/// </summary>
/// <param name="targetType">Type where to search for Action methods</param>
/// <param name="args">Arguments that will be converted to Action method arguments</param>
/// <param name="messenger">Uses for writing messages instead of Console class methods</param>
/// <param name="notationType">Switch for command line syntax. Windows: /param:value Linux: -param value</param>
public static void Run(Type targetType, string[] args, IMessenger messenger, Notation notationType = Notation.Windows)
{
try
{
new Consolery(targetType, null, args, messenger, notationType).RunAction();
}
catch (NConsolerException e)
{
messenger.Write(e.Message);
const int genericErrorExitCode = 1;
Environment.ExitCode = genericErrorExitCode;
}
}
private void command_BeforeExecute(Command source, Notation notation, Optimizer optimizer, QueryContext context)
{
this.context = context;
Notation.Record[] recs = notation.Select(Descriptor.Root, 1);
if (recs.Length > 0)
{
Notation.Record[] recsd = notation.Select(recs[0].Arg0, Descriptor.Binding, 1);
if (recsd.Length > 0)
throw new ESQLException("Query parameters is not supported in XQueryConsole", null);
}
if (context.UseSampleData)
{
String path = Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Data");
if (Directory.Exists(path))
context.DatabaseDictionary.SearchPath = path;
}
}
public void StringToDecimal_InputTooBigValues_ThrowsOverflowException(string number, int scale)
{
Notation notation = new Notation(scale);
NUnit.Framework.Assert.Throws <OverflowException>(() => StringToDecimal.ConvertingToDecimal(number, notation));
}
public virtual void WriteTypeswitch(Notation.Record rec)
{
WriteText("typeswitch (");
WriteExpr(rec.args[0]);
WriteText(")");
Symbol[] arr = Lisp.ToArray<Symbol>(rec.args[1]);
for (int k = 0; k < arr.Length; k++)
{
Notation.Record[] recs = notation.Select(arr[k], new Descriptor[] { Descriptor.Case });
if (recs.Length > 0)
{
WriteText(" case ");
if (recs[0].args.Length > 2)
{
WriteText('$');
WriteVarName((VarName)recs[0].Arg0);
WriteText(" as ");
WriteSequenceType(recs[0].Arg1);
WriteText(" return ");
WriteExprSingle(recs[0].Arg2);
}
else
{
WriteSequenceType(recs[0].Arg0);
WriteText(" return ");
WriteExprSingle(recs[0].Arg1);
}
}
}
if (rec.args.Length > 3)
{
WriteText(" default $");
WriteVarName((VarName)rec.Arg2);
WriteText(" return ");
WriteExprSingle(rec.Arg3);
}
else
{
WriteText(" default return ");
WriteExprSingle(rec.Arg2);
}
}
public virtual void WriteLetOperator(Notation.Record rec)
{
WriteText("let ");
Symbol[] arr = Lisp.ToArray<Symbol>(rec.args[0]);
for (int k = 0; k < arr.Length; k++)
{
Notation.Record[] recs = notation.Select(arr[k], Descriptor.LetClauseOperator, 3);
if (recs.Length > 0)
{
if (k > 0)
WriteText(", ");
WriteText('$');
WriteVarName((VarName)recs[0].Arg0);
if (recs[0].Arg1 != null)
{
WriteText(' ');
WriteTypeDecl(recs[0].Arg1);
}
WriteText(" := ");
WriteExprSingle(recs[0].Arg2);
}
}
}
public virtual void WriteOptionDecl(Notation.Record rec)
{
WriteText("declare option ");
WriteQName((Qname)rec.Arg0);
WriteText(' ');
WriteLiteral((Literal)rec.Arg1);
}
public void NotationHasDisplayValueTest([Values] Notation notation) => Assert.That(notation.GetDisplayValue(), Is.Not.Null.And.Not.Empty);
public virtual void WriteCopyNamespace(Notation.Record rec)
{
WriteText("declare copy-namespaces ");
TokenWrapper wrapper = (TokenWrapper)rec.Arg0;
switch (wrapper.Data)
{
case Token.PRESERVE:
WriteText("preserve");
break;
case Token.NO_PRESERVE:
WriteText("no-preserve");
break;
}
WriteText(", ");
wrapper = (TokenWrapper)rec.Arg1;
switch (wrapper.Data)
{
case Token.INHERIT:
WriteText("inherit");
break;
case Token.NO_INHERIT:
WriteText("no-inherit");
break;
}
}
public virtual void WriteImportModule(Notation.Record rec)
{
Literal[] arr;
WriteText("import module ");
if (rec.args.Length == 2)
{
WriteLiteral((Literal)rec.Arg0);
arr = Lisp.ToArray<Literal>(rec.args[1]);
}
else
{
WriteText("namespace ");
WriteQName((Qname)rec.Arg0);
WriteText('=');
WriteLiteral((Literal)rec.Arg1);
arr = Lisp.ToArray<Literal>(rec.args[2]);
}
WriteText(" at ");
for (int k = 0; k < arr.Length; k++)
{
if (k > 0)
WriteText(", ");
WriteLiteral(arr[k]);
}
}
public void NotationHasNatureTest([Values] Notation notation) => Assert.True(natures.Contains(notation.GetNature()));
public ActionResult Index(
long[] matterIds,
short characteristicLinkId,
Notation notation,
Feature[] features,
string maxDifference,
string excludeType)
{
return(CreateTask(() =>
{
if (matterIds.Length != 2)
{
throw new ArgumentException("Count of selected matters must be 2.", nameof(matterIds));
}
long firstMatterId = matterIds[0];
long firstParentSequenceId = db.CommonSequence.Single(c => c.MatterId == firstMatterId && c.Notation == notation).Id;
Subsequence[] firstSequenceSubsequences = subsequenceExtractor.GetSubsequences(firstParentSequenceId, features);
List <double> firstSequenceCharacteristics = CalculateCharacteristic(characteristicLinkId, firstSequenceSubsequences);
Dictionary <long, AttributeValue[]> firstDbSubsequencesAttributes = sequenceAttributeRepository.GetAttributes(firstSequenceSubsequences.Select(s => s.Id));
var firstSequenceAttributes = new List <AttributeValue[]>();
foreach (Subsequence subsequence in firstSequenceSubsequences)
{
firstDbSubsequencesAttributes.TryGetValue(subsequence.Id, out AttributeValue[] attributes);
attributes = attributes ?? new AttributeValue[0];
firstSequenceAttributes.Add(attributes);
}
long secondMatterId = matterIds[1];
long secondParentSequenceId = db.CommonSequence.Single(c => c.MatterId == secondMatterId && c.Notation == notation).Id;
Subsequence[] secondSequenceSubsequences = subsequenceExtractor.GetSubsequences(secondParentSequenceId, features);
List <double> secondSequenceCharacteristics = CalculateCharacteristic(characteristicLinkId, secondSequenceSubsequences);
Dictionary <long, AttributeValue[]> secondDbSubsequencesAttributes = sequenceAttributeRepository.GetAttributes(secondSequenceSubsequences.Select(s => s.Id));
var secondSequenceAttributes = new List <AttributeValue[]>();
foreach (Subsequence subsequence in secondSequenceSubsequences)
{
secondDbSubsequencesAttributes.TryGetValue(subsequence.Id, out AttributeValue[] attributes);
attributes = attributes ?? new AttributeValue[0];
secondSequenceAttributes.Add(attributes);
}
double difference = double.Parse(maxDifference, CultureInfo.InvariantCulture);
var similarSubsequences = new List <IntPair>();
for (int i = 0; i < firstSequenceCharacteristics.Count; i++)
{
for (int j = 0; j < secondSequenceCharacteristics.Count; j++)
{
if (Math.Abs(firstSequenceCharacteristics[i] - secondSequenceCharacteristics[j]) <= difference)
{
similarSubsequences.Add(new IntPair(i, j));
if (excludeType == "Exclude")
{
firstSequenceCharacteristics[i] = double.NaN;
secondSequenceCharacteristics[j] = double.NaN;
}
}
}
}
var characteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkId, notation);
var similarity = similarSubsequences.Count * 200d / (firstSequenceSubsequences.Length + secondSequenceSubsequences.Length);
var firstSequenceSimilarity = similarSubsequences.Count * 100d / firstSequenceSubsequences.Length;
var secondSequenceSimilarity = similarSubsequences.Count * 100d / secondSequenceSubsequences.Length;
return new Dictionary <string, object>
{
{ "firstSequenceName", db.Matter.Single(m => m.Id == firstMatterId).Name },
{ "secondSequenceName", db.Matter.Single(m => m.Id == secondMatterId).Name },
{ "characteristicName", characteristicName },
{ "similarSubsequences", similarSubsequences },
{ "similarity", similarity },
{ "firstSequenceSimilarity", firstSequenceSimilarity },
{ "secondSequenceSimilarity", secondSequenceSimilarity },
{ "firstSequenceSubsequences", firstSequenceSubsequences },
{ "secondSequenceSubsequences", secondSequenceSubsequences },
{ "firstSequenceAttributes", firstSequenceAttributes },
{ "secondSequenceAttributes", secondSequenceAttributes }
};
}));
}
public ActionResult Index(
long[] matterIds,
OrderTransformation[] transformationsSequence,
int iterationsCount,
short[] characteristicLinkIds,
Notation[] notations,
Language?[] languages,
Translator?[] translators,
PauseTreatment?[] pauseTreatments,
bool?[] sequentialTransfers,
ImageOrderExtractor?[] trajectories)
{
return(CreateTask(() =>
{
Dictionary <long, string> mattersNames = Cache.GetInstance().Matters.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id, m => m.Name);
Chain[][] sequences = new Chain[matterIds.Length][];
using (var db = new LibiadaWebEntities())
{
var commonSequenceRepository = new CommonSequenceRepository(db);
long[][] sequenceIds = commonSequenceRepository.GetSequenceIds(matterIds,
notations,
languages,
translators,
pauseTreatments,
sequentialTransfers,
trajectories);
for (int i = 0; i < matterIds.Length; i++)
{
sequences[i] = new Chain[characteristicLinkIds.Length];
for (int j = 0; j < characteristicLinkIds.Length; j++)
{
sequences[i][j] = commonSequenceRepository.GetLibiadaChain(sequenceIds[i][j]);
}
}
}
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
var sequencesCharacteristics = new SequenceCharacteristics[matterIds.Length];
matterIds = matterIds.OrderBy(m => m).ToArray();
for (int i = 0; i < matterIds.Length; i++)
{
long matterId = matterIds[i];
var characteristics = new double[characteristicLinkIds.Length];
for (int j = 0; j < characteristicLinkIds.Length; j++)
{
Notation notation = notations[j];
Chain sequence = sequences[i][j];
for (int l = 0; l < iterationsCount; l++)
{
for (int k = 0; k < transformationsSequence.Length; k++)
{
sequence = transformationsSequence[k] == OrderTransformation.Dissimilar ? DissimilarChainFactory.Create(sequence)
: HighOrderFactory.Create(sequence, EnumExtensions.GetLink(transformationsSequence[k]));
}
}
int characteristicLinkId = characteristicLinkIds[j];
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
IFullCalculator calculator = FullCalculatorsFactory.CreateCalculator(characteristic);
characteristics[j] = calculator.Calculate(sequence, link);
}
sequencesCharacteristics[i] = new SequenceCharacteristics
{
MatterName = mattersNames[matterId],
Characteristics = characteristics
};
}
var characteristicNames = new string[characteristicLinkIds.Length];
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k], notations[k]);
characteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = characteristicNames[k],
Selected = false
};
}
var transformations = transformationsSequence.Select(ts => ts.GetDisplayValue());
var result = new Dictionary <string, object>
{
{ "characteristics", sequencesCharacteristics },
{ "characteristicNames", characteristicNames },
{ "characteristicsList", characteristicsList },
{ "transformationsList", transformations },
{ "iterationsCount", iterationsCount }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public JsonResult Recovery(Task task, TypeRecovery typeRecovery, IDictionary <string, string> nameAndValue, bool IsAPI = false)
{
#region Демо режим
if (Platform.IsDemo)
{
return(Json(new Text("Операция недоступна в демо-режиме")));
}
#endregion
DateTime DateRecovery = default(DateTime);
#region Проверка данных
if (string.IsNullOrWhiteSpace(task.Description))
{
return(Json(new Text("Имя задания не может быть пустым")));
}
if (string.IsNullOrWhiteSpace(task.Whence))
{
return(Json(new Text("Локальный каталог не может быть пустым")));
}
if (string.IsNullOrWhiteSpace(task.Where))
{
return(Json(new Text("Удаленный каталог не может быть пустым")));
}
switch (task.TypeSunc)
{
case TypeSunc.SFTP:
case TypeSunc.FTP:
{
if (string.IsNullOrWhiteSpace(task.FTP.HostOrIP) || string.IsNullOrWhiteSpace(task.FTP.Login) || string.IsNullOrWhiteSpace(task.FTP.Passwd))
{
return(Json(new Text("Настройки 'FTP/SFTP' имеют недопустимое значение")));
}
break;
}
case TypeSunc.WebDav:
{
if (string.IsNullOrWhiteSpace(task.WebDav.url) || string.IsNullOrWhiteSpace(task.WebDav.Login) || string.IsNullOrWhiteSpace(task.WebDav.Passwd))
{
return(Json(new Text("Настройки 'WebDav' имеют недопустимое значение")));
}
break;
}
case TypeSunc.OneDrive:
{
if (string.IsNullOrWhiteSpace(task.OneDrive.ApplicationId) || string.IsNullOrWhiteSpace(task.OneDrive.RefreshToken))
{
return(Json(new Text("Настройки 'OneDrive' имеют недопустимое значение")));
}
break;
}
}
if (task.EncryptionAES && string.IsNullOrWhiteSpace(task.PasswdAES))
{
return(Json(new Text("Пароль для шифрования файлов не может быть пустым")));
}
if (typeRecovery == TypeRecovery.Date && nameAndValue.TryGetValue("TypeRecoveryToDate", out string DateRecoveryTostring) && !DateTime.TryParse(DateRecoveryTostring, out DateRecovery))
{
return(Json(new Text("Отметка бэкапа имеет неправильный формат")));
}
#endregion
#region Добовляем задание в WorkNote
CancellationToken cancellationToken = new CancellationToken();
var WorkNoteNotation = new Notation()
{
TaskId = task.Id,
Category = "Восстановление",
Msg = $"Задание: {task.Description}",
Time = DateTime.Now,
More = new List <More>()
{
new More("Состояние", "Выполняется поиск всех папок")
}
};
CoreDB.SyncBackupWorkNote.Add(WorkNoteNotation, cancellationToken);
#endregion
// Выполняем задание в потоке
ThreadPool.QueueUserWorkItem(ob =>
{
// Создание отчета по ошибкам
Report report = new Report(task);
// Выполняем задание
Tools.Recovery(task, new RemoteServer(task.TypeSunc, task.FTP, task.WebDav, task.OneDrive, report, out _), WorkNoteNotation, out List <More> ResponseNameAndValue, typeRecovery, DateRecovery);
// Сохраняем отчет об ошибках (если есть ошибки)
report.SaveAndDispose(ref ResponseNameAndValue);
// Чистим WorkNote
CoreDB.SyncBackupWorkNote.Take(cancellationToken);
#region Сохраняем данные задание в базе
SqlToMode.SetMode(SqlMode.Read);
using (CoreDB coreDB = Service.Get <CoreDB>())
{
// Добовляем задание в список завершеных операций
coreDB.SyncBackup_Notations.Add(new Notation()
{
TaskId = task.Id,
Category = "Восстановление",
Msg = $"Задание: {task.Description}",
Time = DateTime.Now,
More = ResponseNameAndValue,
});
// Сохраняем базу
coreDB.SaveChanges();
}
SqlToMode.SetMode(SqlMode.ReadOrWrite);
#endregion
});
// Отдаем ответ
if (IsAPI)
{
return(Json(new TrueOrFalse(true)));
}
return(Json(new Text("Задание добавлено на обработку")));
}
public void NotationHasDescriptionTest([Values] Notation notation) => Assert.That(notation.GetDescription(), Is.Not.Null.And.Not.Empty);
public void StringToDecimal_InpotNullOrEmptyValues_ThrowsNullException(string number, int scale)
{
Notation notation = new Notation(scale);
NUnit.Framework.Assert.Throws <ArgumentNullException>(() => StringToDecimal.ConvertingToDecimal(number, notation));
}
public virtual void WriteDefaultNamespaceDecl(Notation.Record rec)
{
switch (rec.descriptor)
{
case Descriptor.DefaultElement:
WriteText("declare default element namespace ");
break;
case Descriptor.DefaultFunction:
WriteText("declare default function namespace ");
break;
}
WriteLiteral((Literal)rec.Arg0);
}
private void WriteDefaultOrder(Notation.Record rec)
{
WriteText("declare default order ");
TokenWrapper wrapper = (TokenWrapper)rec.Arg0;
switch (wrapper.Data)
{
case Token.EMPTY_GREATEST:
WriteText("empty greatest");
break;
case Token.EMPTY_LEAST:
WriteText("empty least");
break;
}
}
public virtual void WriteFuncDecl(Notation.Record rec)
{
WriteText("declare function ");
WriteQName((Qname)rec.Arg0);
WriteText('(');
WriteParamList(rec.args[1]);
WriteText(')');
if (rec.args.Length > 3)
{
WriteText(" as ");
WriteSequenceType(rec.Arg2);
if (rec.args[3] == null)
WriteText(" external");
else
{
SmartNewLine();
WriteText('{');
SmartNewLine();
WriteExpr(rec.args[3]);
SmartNewLine();
WriteText('}');
}
}
else
{
if (rec.args[2] == null)
WriteText(" external");
else
{
SmartNewLine();
WriteText('{');
SmartNewLine();
WriteExpr(rec.args[2]);
SmartNewLine();
WriteText('}');
}
}
}
public virtual void WriteImportSchema(Notation.Record rec)
{
WriteText("import schema ");
if (rec.Arg0 != null)
{
Notation.Record[] recs = notation.Select(rec.Arg0, Descriptor.Namespace, 1);
if (recs.Length > 0)
{
WriteQName((Qname)recs[0].Arg0);
WriteText("=");
}
else
{
recs = notation.Select(rec.Arg0, Descriptor.DefaultElement, 0);
if (recs.Length > 0)
WriteText("default element namespace ");
else
throw new InvalidOperationException();
}
}
WriteLiteral((Literal)rec.Arg1);
if (rec.args[2] != null)
{
WriteText(" at ");
Literal[] arr = Lisp.ToArray<Literal>(rec.args[2]);
for (int k = 0; k < arr.Length; k++)
{
if (k > 0)
WriteText(", ");
WriteLiteral(arr[k]);
}
}
}
public void NotationNamesTest(Notation notation, string name) => Assert.AreEqual(name, notation.GetName());
public virtual void WriteNamespaceDecl(Notation.Record rec)
{
WriteText("declare namespace ");
WriteQName((Qname)rec.Arg0);
WriteText('=');
WriteLiteral((Literal)rec.Arg1);
}
public virtual void WriteAttributeTest(Notation.Record rec)
{
WriteText("attribute(");
if (rec.Arg0.Tag == Tag.TokenWrapper)
{
if (((TokenWrapper)rec.Arg0).Data == '*')
WriteText('*');
}
else
WriteQName((Qname)rec.Arg0);
if (rec.args.Length > 1)
{
WriteText(", ");
WriteTypeName(rec.Arg1);
}
WriteText(")");
}
public virtual void WriteVarDecl(Notation.Record rec)
{
WriteText("declare variable $");
WriteVarName((VarName)rec.Arg0);
if (rec.Arg1 != null)
{
WriteText(' ');
WriteTypeDecl(rec.Arg1);
}
WriteText(" := ");
if (rec.args.Length > 2)
WriteExprSingle(rec.Arg2);
else
WriteText("external");
}
public virtual void WriteSchemaElementTest(Notation.Record rec)
{
WriteText("schema-element(");
WriteQName((Qname)rec.Arg0);
WriteText(")");
}
public XQueryAbstractWriter(Notation notation)
{
this.notation = notation;
}
public virtual void WriteSchemaAttributeTest(Notation.Record rec)
{
WriteText("schema-attribute(");
WriteQName((Qname)rec.Arg0);
WriteText(")");
}
public virtual void WriteFLORExpr(Notation.Record rec)
{
Symbol[] arr = Lisp.ToArray<Symbol>(rec.args[0]);
for (int k = 0; k < arr.Length; k++)
{
if (k > 0)
WriteText(' ');
Notation.Record[] recs = notation.Select(arr[k]);
switch (recs[0].descriptor)
{
case Descriptor.For:
WriteForOperator(recs[0]);
break;
case Descriptor.Let:
WriteLetOperator(recs[0]);
break;
default:
throw new InvalidOperationException();
}
}
if (rec.Arg1 != null)
WriteWhereClause(rec.Arg1);
if (rec.Arg2 != null)
WriteOrderByClause(rec.Arg2);
WriteText(" return ");
WriteExprSingle(rec.Arg3);
}
public virtual void WriteDefaultCollaction(Notation.Record rec)
{
WriteText("declare default collation ");
WriteLiteral((Literal)rec.Arg0);
}
public virtual void WriteQuantifiedExpr(Notation.Record rec)
{
switch (rec.descriptor)
{
case Descriptor.Some:
WriteText("some ");
break;
case Descriptor.Every:
WriteText("every ");
break;
}
Symbol[] arr = Lisp.ToArray<Symbol>(rec.args[0]);
for (int k = 0; k < arr.Length; k++)
{
Notation.Record[] recs = notation.Select(arr[k], Descriptor.QuantifiedExprOper, 3);
if (recs.Length > 0)
{
if (k > 0)
WriteText(", ");
WriteText('$');
WriteVarName((VarName)recs[0].Arg0);
if (recs[0].Arg1 != null)
{
WriteText(' ');
WriteTypeDecl(recs[0].Arg1);
}
WriteText(" in ");
WriteExprSingle(recs[0].Arg2);
}
}
WriteText(" satisfies ");
WriteExprSingle(rec.Arg1);
}
public virtual void WriteBaseUri(Notation.Record rec)
{
WriteText("declare base-uri ");
WriteLiteral((Literal)rec.Arg0);
}
public virtual void WriteIfExpr(Notation.Record rec)
{
WriteText(" if (");
WriteExpr(rec.args[0]);
WriteText(") then ");
WriteExprSingle(rec.Arg1);
WriteText(" else ");
WriteExprSingle(rec.Arg2);
}
public virtual void WriteConstructionDecl(Notation.Record rec)
{
WriteText("declare construction ");
TokenWrapper wrapper = (TokenWrapper)rec.Arg0;
switch (wrapper.Data)
{
case Token.PRESERVE:
WriteText("preserve");
break;
case Token.STRIP:
WriteText("strip");
break;
}
}
protected virtual void WriteXmlNamespaces(Notation.Record[] recs)
{
WriteText("XMLNAMESPACES (");
Symbol[] arr = Lisp.ToArray<Symbol>(recs[0].args[0]);
for (int k = 0; k < arr.Length; k++)
{
if (k > 0)
WriteText(", ");
if (arr[k] == null)
WriteText("NO DEFAULT");
else
{
Notation.Record[] recs1 = notation.Select(arr[k], Descriptor.DeclNamespace, 2);
if (recs1.Length > 0)
if (recs1[0].Arg1 == null)
{
WriteText("DEFAULT ");
WriteUnsignedLit((Value)recs1[0].Arg0);
}
else
{
WriteUnsignedLit((Value)recs1[0].Arg0);
WriteText(" AS ");
WriteQualifiedName((Qname)recs1[0].Arg1);
}
else
throw new InvalidOperationException();
}
}
WriteText(")");
}
public virtual void WriteOrdering(Notation.Record rec)
{
WriteText("declare ordering ");
TokenWrapper wrapper = (TokenWrapper)rec.Arg0;
switch (wrapper.Data)
{
case Token.ORDERED:
WriteText("ordered");
break;
case Token.UNORDERED:
WriteText("unordered");
break;
}
}
public YYParser(Notation notation)
{
errorText = new StringWriter();
this.notation = notation;
}
public int StringToDecimal_CorrectValues_PositiveTest(string number, int scale)
{
Notation notation = new Notation(scale);
return(StringToDecimal.ConvertingToDecimal(number, notation));
}
