private async Task RefreshPropertiesAsync()
{
try
{
IsBusy = true;
var result = await _searchService.FindProperties(_navigationParams.location, _navigationParams.toLet);
_currentPage = result.MetaData.PageNumber;
_hasNextPage = result.MetaData.HasNextPage;
_total = result.MetaData.TotalItemCount;
PropertiesList.Clear();
foreach (var property in result.Properties)
{
PropertiesList.Add(property);
}
UpdateDisplyingDescription();
if (_isInitialised == false)
{
_isInitialised = true;
}
}
catch (Exception exc)
{
_log.ErrorException("An error has occurred while trying to get search results", exc);
await _useDialogs.AlertAsync("An error has occurred. Please try again.");
}
finally
{
IsBusy = false;
}
}
private async Task LoadMorePropertiesAsync(SearchPropertyResult searchPropertyResult)
{
if (searchPropertyResult == null)
{
return;
}
if (PropertiesList[PropertiesList.Count - 1] == searchPropertyResult && _hasNextPage)
{
await Task.Delay(1000);//Only required to be able to view ActivityIndicator in the footer.
LoadingNextPage = true;
}
if (LoadingNextPage == true)
{
var result = await _searchService.FindProperties(_locationPrompt, _toLet, _currentPage + 1);
_currentPage = result.MetaData.PageNumber;
_hasNextPage = result.MetaData.HasNextPage;
foreach (var property in result.Properties)
{
PropertiesList.Add(property);
}
UpdateDisplyingDescription();
LoadingNextPage = false;
}
}
/// <summary>
/// Displays a list of available values for the specified component than sets the value.
/// </summary>
/// <param name="context">An ITypeDescriptorContext that can be used to gain additional context information.</param>
/// <param name="provider">A service provider object through which editing services may be obtained.</param>
/// <param name="value">An instance of the value being edited.</param>
/// <returns>The new value of the object. If the value of the object hasn't changed, this method should return the same object it was passed.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (provider != null)
{
// This service is in charge of popping our ListBox.
var service1 = ((IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)));
if (service1 != null)
{
// This is an internal Microsoft class representing the PropertyGrid entry for our component.
if (provider.GetType().FullName == "System.Windows.Forms.PropertyGridInternal.PropertyDescriptorGridEntry")
{
var list = new PropertiesList(context);
// Drop the list control.
service1.DropDownControl(list);
if (list.SelectedIndices.Count == 1)
{
value = list.SelectedItem.ToString();
}
// Close the list control after selection.
service1.CloseDropDown();
}
}
}
return(value);
}
/// <summary>
/// Get after calculate properties list
/// </summary>
/// <returns></returns>
public PropertiesList GetCurrentPropertiesList()
{
PropertiesList buffer = GetBasicWeaponProperties();
buffer = GetUpgradeSet()[UpgradeLevel].Calculate(buffer);
return(buffer);
}
public void AddProperty(string key, PropertyInfoEx newProp)
{
var newIndex = PropertiesList.Count;
newProp.propertyPositionIndex = (short)newIndex;
PropertiesList.Add(newProp);
this.Add(key, newIndex);
}
/// <summary>
/// Update the required materials list.
/// </summary>
private void UpdateRequiredMaterialsList()
{
int scrollBarPosition = PropertiesList.GetVerticalScrollBarPosition();
// Store the selected item (if any) to restore it after the update
int selectedItem = PropertiesList.SelectedItems.Count > 0
? PropertiesList.SelectedItems[0].Tag.GetHashCode()
: 0;
PropertiesList.BeginUpdate();
try
{
// Clear everything
PropertiesList.Items.Clear();
PropertiesList.Groups.Clear();
PropertiesList.Columns.Clear();
// Create the columns
PropertiesList.Columns.Add("item", "Item");
PropertiesList.Columns.Add("qBase", "Quantity (Base)");
if (Character != null)
{
PropertiesList.Columns.Add("quant", "Quantity (You)");
}
IEnumerable <ListViewItem> items = AddGroups();
// Add the items
PropertiesList.Items.AddRange(items.OrderBy(x => x.Text).ToArray());
// Show/Hide the "no item required" label and autoresize the columns
PropertiesList.Visible = PropertiesList.Items.Count > 0;
if (PropertiesList.Items.Count > 0)
{
AdjustColumns();
}
if (selectedItem <= 0)
{
return;
}
// Restore the selected item (if any)
foreach (ListViewItem lvItem in PropertiesList.Items.Cast <ListViewItem>().Where(
lvItem => lvItem.Tag.GetHashCode() == selectedItem))
{
lvItem.Selected = true;
}
}
finally
{
PropertiesList.EndUpdate();
PropertiesList.SetVerticalScrollBarPosition(scrollBarPosition);
}
}
private void UpdateDisplyingDescription()
{
if (PropertiesList.Any())
{
DisplayingDescription = $"Showing {PropertiesList.Count} of {_total} results";
}
else
{
DisplayingDescription = "No results found";
}
}
public void AddName(object sender, RoutedEventArgs e)
{
try
{
PropertiesList newListItem = new PropertiesList();
newListItem.PropID = EditingProperty.ID;
newListItem.Value = "";
NameList.Add(newListItem);
ListBoxNames.Items.Refresh();
int ind = ListBoxNames.Items.Count - 1;
ListBoxNames.SelectedIndex = ind;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Ошибка");
}
}
public void AddProperty(Property p)
{
if (PropertyById.ContainsKey(p.ID))
{
throw new InvalidOperationException(String.Format("Property with ID={0} already exists", p.ID));
}
if (PropertyByCompactId.ContainsKey(p.CompactID))
{
throw new InvalidOperationException(String.Format("Property with CompactID={0} already exists", p.ID));
}
PropertyById[p.ID] = p;
PropertyByCompactId[p.CompactID] = p;
PropertiesList.Add(p);
p.Schema = this;
}
public HierarchyNode()
{
Id = System.Threading.Interlocked.Increment(ref Counter);
allItems.Add(this);
Children = new NotifyingList <HierarchyNode>();
Properties = new PropertiesList();
Commands = new CommandsList(this);
Children.ItemAdded += (s, a) =>
{
a.Item.Parent = this;
this.NotifyChildAdded(a.Item);
};
Children.ItemRemoved += (s, a) =>
{
this.NotifyChildRemoved(a.Item);
a.Item.Parent = null;
};
}
private async Task LoadMorePropertiesAsync(SearchPropertyResult searchPropertyResult)
{
if (searchPropertyResult == null)
{
return;
}
if (PropertiesList[PropertiesList.Count - 1] == searchPropertyResult)
{
if (_hasNextPage)
{
try
{
IsBusy = true;
var result = await _searchService.FindProperties(_navigationParams.location, _navigationParams.toLet, _currentPage + 1);
_currentPage = result.MetaData.PageNumber;
_hasNextPage = result.MetaData.HasNextPage;
_total = result.MetaData.TotalItemCount;
foreach (var property in result.Properties)
{
PropertiesList.Add(property);
}
UpdateDisplyingDescription();
}
catch (Exception exc)
{
_log.ErrorException("An error has occurred while trying to get more results", exc);
await _useDialogs.AlertAsync("An error has occurred. Please try again.");
}
finally
{
IsBusy = false;
}
}
}
}
/// <summary>
/// Displays a list of available values for the specified component than sets the value.
/// </summary>
/// <param name="context">An ITypeDescriptorContext that can be used to gain additional context information.</param>
/// <param name="provider">A service provider object through which editing services may be obtained.</param>
/// <param name="value">An instance of the value being edited.</param>
/// <returns>The new value of the object. If the value of the object hasn't changed, this method should return the same object it was passed.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (provider != null)
{
// This service is in charge of popping our ListBox.
var service1 = ((IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)));
if (service1 != null)
{
// This is an internal Microsoft class representing the PropertyGrid entry for our component.
if (provider.GetType().FullName == "System.Windows.Forms.PropertyGridInternal.PropertyDescriptorGridEntry")
{
var list = new PropertiesList(context);
// Drop the list control.
service1.DropDownControl(list);
if (list.SelectedIndices.Count == 1)
{
value = list.SelectedItem.ToString();
}
// Close the list control after selection.
service1.CloseDropDown();
}
}
}
return value;
}
private List <StiToken> PostProcessTokensList(List <StiToken> tokensList)
{
List <StiToken> newList = new List <StiToken>();
tokenPos = 0;
while (tokenPos < tokensList.Count)
{
StiToken token = tokensList[tokenPos];
tokenPos++;
if (token.Type == StiTokenType.Identifier)
{
StiDataSource ds = report.Dictionary.DataSources[token.Value];
StiBusinessObject bos = report.Dictionary.BusinessObjects[token.Value];
#region check for DataSource field
if (ds != null)
{
StringBuilder fieldPath = new StringBuilder(StiNameValidator.CorrectName(token.Value));
while (tokenPos + 1 < tokensList.Count && tokensList[tokenPos].Type == StiTokenType.Dot)
{
token = tokensList[tokenPos + 1];
string nextName = StiNameValidator.CorrectName(token.Value);
StiDataRelation dr = GetDataRelationByName(nextName, ds);
if (dr != null)
{
ds = dr.ParentSource;
tokenPos += 2;
fieldPath.Append(".");
fieldPath.Append(dr.NameInSource);
continue;
}
if (ds.Columns.Contains(nextName))
{
tokenPos += 2;
fieldPath.Append(".");
fieldPath.Append(nextName);
break;
}
foreach (StiDataColumn column in ds.Columns)
{
if (StiNameValidator.CorrectName(column.Name) == nextName)
{
tokenPos += 2;
fieldPath.Append(".");
fieldPath.Append(column.NameInSource);
break;
}
}
CheckDataSourceField(ds.Name, nextName);
tokenPos += 2;
fieldPath.Append(".");
fieldPath.Append(nextName);
//token = tokensList[tokenPos - 1];
break;
}
token.Type = StiTokenType.DataSourceField;
//надо оптимизировать и сохранять сразу массив строк !!!!!
token.Value = fieldPath.ToString();
}
#endregion
#region check for BusinessObject field
else if (bos != null)
{
StringBuilder fieldPath = new StringBuilder(token.Value);
while (tokenPos + 1 < tokensList.Count && tokensList[tokenPos].Type == StiTokenType.Dot)
//while (inputExpression[pos2] == '.')
{
token = tokensList[tokenPos + 1];
string nextName = token.Value;
if (bos.Columns.Contains(nextName))
{
tokenPos += 2;
fieldPath.Append(".");
fieldPath.Append(nextName);
break;
}
bos = bos.BusinessObjects[nextName];
if (bos != null)
{
tokenPos += 2;
fieldPath.Append(".");
fieldPath.Append(bos.Name);
continue;
}
break;
}
token.Type = StiTokenType.BusinessObjectField;
//надо оптимизировать и сохранять сразу массив строк !!!!!
token.Value = fieldPath.ToString();
}
#endregion
else if ((newList.Count > 0) && (newList[newList.Count - 1].Type == StiTokenType.Dot))
{
if (MethodsList.Contains(token.Value))
{
token.Type = StiTokenType.Method;
}
else if (PropertiesList.Contains(token.Value))
{
token.Type = StiTokenType.Property;
}
else
{
ThrowError(ParserErrorCode.FieldMethodOrPropertyNotFound, token, token.Value);
}
}
else if (TypesList.Contains(token.Value))
{
token.Type = StiTokenType.Cast;
if ((tokenPos + 1 < tokensList.Count) && (tokensList[tokenPos].Type == StiTokenType.Dot))
{
string tempName = token.Value + "." + tokensList[tokenPos + 1].Value;
if (FunctionsList.Contains(tempName))
{
token.Type = StiTokenType.Function;
token.Value = tempName;
tokenPos += 2;
}
if (SystemVariablesList.Contains(tempName))
{
token.Type = StiTokenType.SystemVariable;
token.Value = tempName;
tokenPos += 2;
}
}
}
else if (ComponentsList.Contains(token.Value))
{
token.Type = StiTokenType.Component;
if ((tokenPos + 1 < tokensList.Count) && (tokensList[tokenPos].Type == StiTokenType.Colon) && ComponentsList.Contains(tokensList[tokenPos + 1].Value))
{
StiComponent comp = (StiComponent)ComponentsList[tokensList[tokenPos + 1].Value];
if (comp != null && comp is StiDataBand)
{
token.Value = (comp as StiDataBand).DataSourceName;
token.Type = StiTokenType.DataSourceField;
tokenPos += 2;
}
}
}
else if (FunctionsList.Contains(token.Value))
{
while ((StiFunctionType)FunctionsList[token.Value] == StiFunctionType.NameSpace)
{
if (tokenPos + 1 >= tokensList.Count)
{
ThrowError(ParserErrorCode.UnexpectedEndOfExpression);
}
token.Value += "." + tokensList[tokenPos + 1].Value;
tokenPos += 2;
if (!FunctionsList.Contains(token.Value))
{
ThrowError(ParserErrorCode.FunctionNotFound, token, token.Value);
}
}
token.Type = StiTokenType.Function;
}
else if (SystemVariablesList.Contains(token.Value) && (token.Value != "value" || component is Stimulsoft.Report.CrossTab.StiCrossCell))
{
token.Type = StiTokenType.SystemVariable;
}
//else if (token.Value.ToLowerInvariant() == "true" || token.Value.ToLowerInvariant() == "false")
//{
// if (token.Value.ToLowerInvariant() == "true")
// token.ValueObject = true;
// else
// token.ValueObject = false;
// token.Type = StiTokenType.Number;
//}
//else if (token.Value.ToLowerInvariant() == "null")
//{
// token.ValueObject = null;
// token.Type = StiTokenType.Number;
//}
else if (ConstantsList.Contains(token.Value))
{
while (ConstantsList[token.Value] == namespaceObj)
{
if (tokenPos + 1 >= tokensList.Count)
{
ThrowError(ParserErrorCode.UnexpectedEndOfExpression);
}
string oldTokenValue = token.Value;
token.Value += "." + tokensList[tokenPos + 1].Value;
tokenPos += 2;
if (!ConstantsList.Contains(token.Value))
{
ThrowError(ParserErrorCode.ItemDoesNotContainDefinition, token, oldTokenValue, tokensList[tokenPos + 1].Value);
}
}
token.ValueObject = ConstantsList[token.Value];
token.Type = StiTokenType.Number;
}
else if (report.Dictionary.Variables.Contains(token.Value))
{
token.Type = StiTokenType.Variable;
}
else if (token.Value == "or" || token.Value == "and" || token.Value == "not")
{
if (token.Value == "or")
{
token.Type = StiTokenType.DoubleOr;
}
if (token.Value == "and")
{
token.Type = StiTokenType.DoubleAnd;
}
if (token.Value == "not")
{
token.Type = StiTokenType.Not;
}
}
else
{
if ((tokenPos < tokensList.Count) && (tokensList[tokenPos].Type != StiTokenType.Dot) || (tokenPos == tokensList.Count))
{
CheckDataSourceField(defaultDataSourceName, token.Value);
token.Type = StiTokenType.DataSourceField;
token.Value = defaultDataSourceName + "." + token.Value;
}
else
{
if ((tokenPos + 1 < tokensList.Count) && (tokensList[tokenPos].Type == StiTokenType.Dot))
{
CheckDataSourceField(token.Value, tokensList[tokenPos + 1].Value);
token.Type = StiTokenType.DataSourceField;
token.Value = token.Value + "." + tokensList[tokenPos + 1].Value;
tokenPos += 2;
}
else
{
ThrowError(ParserErrorCode.NameDoesNotExistInCurrentContext, token, token.Value);
}
}
}
}
newList.Add(token);
}
return(newList);
}
/// <summary>
/// Initialises the dataset <see cref="DataSet"/> using the source of the data set.
/// </summary>
/// <para>
/// A <see cref="DataSet"/> is initialised using the reader to retrieve
/// entity information. The data is only loaded when required by the detection
/// process.
/// </para>
/// <param name="dataSet">A data set to be initialised ready for detection</param>
private static void Load(DataSet dataSet)
{
var reader = dataSet.Pool.GetReader();
try
{
reader.BaseStream.Position = 0;
CommonFactory.LoadHeader(dataSet, reader);
dataSet.Strings = new VariableList<AsciiString<Entities.DataSet>, DataSet>(
dataSet, reader, new StreamAsciiStringFactory(), Constants.StringsCacheSize);
MemoryFixedList<Component, Entities.DataSet> components = null;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
components = new MemoryFixedList<Component, Entities.DataSet>(dataSet, reader, new ComponentFactoryV31());
break;
case BinaryConstants.FormatVersions.PatternV32:
components = new MemoryFixedList<Component, Entities.DataSet>(dataSet, reader, new ComponentFactoryV32());
break;
}
dataSet._components = components;
var maps = new MemoryFixedList<Map, Entities.DataSet>(dataSet, reader, new MapFactory());
dataSet._maps = maps;
var properties = new PropertiesList(dataSet, reader, new PropertyFactory());
dataSet._properties = properties;
dataSet._values = new FixedCacheList<Value, DataSet>(dataSet, reader, new ValueFactory<DataSet>(), Constants.ValuesCacheSize);
dataSet.Profiles = new VariableList<Entities.Profile, DataSet>(dataSet, reader, new ProfileStreamFactory(dataSet.Pool), Constants.ProfilesCacheSize);
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
dataSet._signatures = new FixedCacheList<Signature, DataSet>(dataSet, reader, new SignatureFactoryV31<DataSet>(dataSet), Constants.SignaturesCacheSize);
break;
case BinaryConstants.FormatVersions.PatternV32:
dataSet._signatures = new FixedCacheList<Signature, DataSet>(dataSet, reader, new SignatureFactoryV32<DataSet>(dataSet), Constants.SignaturesCacheSize);
dataSet._signatureNodeOffsets = new IntegerList(dataSet, reader);
dataSet._nodeRankedSignatureIndexes = new IntegerList(dataSet, reader);
break;
}
dataSet._rankedSignatureIndexes = new IntegerList(dataSet, reader);
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
dataSet.Nodes = new VariableList<Entities.Node, DataSet>(dataSet, reader, new NodeStreamFactoryV31(dataSet.Pool), Constants.NodesCacheSize);
break;
case BinaryConstants.FormatVersions.PatternV32:
dataSet.Nodes = new VariableList<Entities.Node, DataSet>(dataSet, reader, new NodeStreamFactoryV32(dataSet.Pool), Constants.NodesCacheSize);
break;
}
var rootNodes = new MemoryFixedList<Entities.Node, Entities.DataSet>(dataSet, reader, new RootNodeFactory());
dataSet.RootNodes = rootNodes;
var profileOffsets = new MemoryFixedList<ProfileOffset, Entities.DataSet>(dataSet, reader, new ProfileOffsetFactory());
dataSet._profileOffsets = profileOffsets;
// Read into memory all the small lists which are frequently accessed.
reader.BaseStream.Position = components.Header.StartPosition;
components.Read(reader);
reader.BaseStream.Position = maps.Header.StartPosition;
maps.Read(reader);
reader.BaseStream.Position = properties.Header.StartPosition;
properties.Read(reader);
reader.BaseStream.Position = rootNodes.Header.StartPosition;
rootNodes.Read(reader);
reader.BaseStream.Position = profileOffsets.Header.StartPosition;
profileOffsets.Read(reader);
}
finally
{
dataSet.Pool.Release(reader);
}
}
/// <summary>
/// Initialises the dataset <see cref="DataSet"/> using the source of the data set.
/// </summary>
/// <para>
/// A <see cref="DataSet"/> is initialised using the reader to retrieve
/// entity information. The data is only loaded when required by the detection
/// process.
/// </para>
/// <param name="dataSet">A data set to be initialised ready for detection</param>
private static void Load(DataSet dataSet)
{
var reader = dataSet.Pool.GetReader();
try
{
reader.BaseStream.Position = 0;
CommonFactory.LoadHeader(dataSet, reader);
dataSet.Strings = new VariableList <AsciiString>(dataSet, reader, new AsciiStringFactory(), Constants.StringsCacheSize);
MemoryFixedList <Component> components = null;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
components = new MemoryFixedList <Component>(dataSet, reader, new ComponentFactoryV31());
break;
case BinaryConstants.FormatVersions.PatternV32:
components = new MemoryFixedList <Component>(dataSet, reader, new ComponentFactoryV32());
break;
}
dataSet._components = components;
var maps = new MemoryFixedList <Map>(dataSet, reader, new MapFactory());
dataSet._maps = maps;
var properties = new PropertiesList(dataSet, reader, new PropertyFactory());
dataSet._properties = properties;
dataSet._values = new FixedCacheList <Value>(dataSet, reader, new ValueFactory(), Constants.ValuesCacheSize);
dataSet.Profiles = new VariableList <Entities.Profile>(dataSet, reader, new ProfileStreamFactory(dataSet.Pool), Constants.ProfilesCacheSize);
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
dataSet._signatures = new FixedCacheList <Signature>(dataSet, reader, new SignatureFactoryV31(dataSet), Constants.SignaturesCacheSize);
break;
case BinaryConstants.FormatVersions.PatternV32:
dataSet._signatures = new FixedCacheList <Signature>(dataSet, reader, new SignatureFactoryV32(dataSet), Constants.SignaturesCacheSize);
dataSet._signatureNodeOffsets = new FixedList <Integer>(dataSet, reader, new IntegerFactory());
dataSet._nodeRankedSignatureIndexes = new FixedList <Integer>(dataSet, reader, new IntegerFactory());
break;
}
dataSet._rankedSignatureIndexes = new FixedCacheList <Integer>(
dataSet, reader, new IntegerFactory(), Constants.RankedSignaturesCacheSize);
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
dataSet.Nodes = new VariableList <Entities.Node>(dataSet, reader, new NodeStreamFactoryV31(dataSet.Pool), Constants.NodesCacheSize);
break;
case BinaryConstants.FormatVersions.PatternV32:
dataSet.Nodes = new VariableList <Entities.Node>(dataSet, reader, new NodeStreamFactoryV32(dataSet.Pool), Constants.NodesCacheSize);
break;
}
var rootNodes = new MemoryFixedList <Entities.Node>(dataSet, reader, new RootNodeFactory());
dataSet.RootNodes = rootNodes;
var profileOffsets = new MemoryFixedList <ProfileOffset>(dataSet, reader, new ProfileOffsetFactory());
dataSet._profileOffsets = profileOffsets;
// Read into memory all the small lists which are frequently accessed.
reader.BaseStream.Position = components.Header.StartPosition;
components.Read(reader);
reader.BaseStream.Position = maps.Header.StartPosition;
maps.Read(reader);
reader.BaseStream.Position = properties.Header.StartPosition;
properties.Read(reader);
reader.BaseStream.Position = rootNodes.Header.StartPosition;
rootNodes.Read(reader);
reader.BaseStream.Position = profileOffsets.Header.StartPosition;
profileOffsets.Read(reader);
}
finally
{
dataSet.Pool.Release(reader);
}
}
private List <StiToken> PostProcessTokensList(List <StiToken> tokensList)
{
List <StiToken> newList = new List <StiToken>();
tokenPos = 0;
while (tokenPos < tokensList.Count)
{
StiToken token = tokensList[tokenPos];
tokenPos++;
if (token.Type == StiTokenType.Identifier)
{
if ((newList.Count > 0) && (newList[newList.Count - 1].Type == StiTokenType.Dot))
{
if (MethodsList.Contains(token.Value))
{
token.Type = StiTokenType.Method;
}
//Proryv
else if (Equals(token.Value, "Value") || ProryvPropertiesList.Contains(token.Value) || PropertiesList.Contains(token.Value))
{
token.Type = StiTokenType.Property;
}
else
{
ThrowError(ParserErrorCode.FieldMethodOrPropertyNotFound, token, token.Value);
}
}
else if (TypesList.Contains(token.Value))
{
token.Type = StiTokenType.Cast;
if ((tokenPos + 1 < tokensList.Count) && (tokensList[tokenPos].Type == StiTokenType.Dot))
{
string tempName = token.Value + "." + tokensList[tokenPos + 1].Value;
if (FunctionsList.Contains(tempName))
{
token.Type = StiTokenType.Function;
token.Value = tempName;
tokenPos += 2;
}
//Proryv
else if (ProryvFunctionsList.Contains(tempName))
{
token.Type = StiTokenType.ProryvFunction;
token.Value = tempName;
tokenPos += 2;
}
if (SystemVariablesList.Contains(tempName))
{
token.Type = StiTokenType.SystemVariable;
token.Value = tempName;
tokenPos += 2;
}
}
}
//Proryv
else if (ProryvFunctionsList.Contains(token.Value))
{
token.Type = StiTokenType.ProryvFunction;
}
else if (_proryvSpreadsheetProperties != null && _proryvSpreadsheetProperties.ContainsKey(token.Value.ToLowerInvariant()))
{
token.Type = StiTokenType.ProryvSpreadsheetProperties;
}
else if (_proryvFreeHierarchyBalanceSignature != null && _proryvFreeHierarchyBalanceSignature.ContainsKey(token.Value.ToLowerInvariant()))
{
token.Type = StiTokenType.ProryvFreeHierarchyBalanceSignature;
}
else if (FunctionsList.Contains(token.Value))
{
while ((ProryvFunctionType)FunctionsList[token.Value] == ProryvFunctionType.NameSpace)
{
if (tokenPos + 1 >= tokensList.Count)
{
ThrowError(ParserErrorCode.UnexpectedEndOfExpression);
}
var np = tokensList[tokenPos + 1].Value;
token.Value += "." + np;
tokenPos += 2;
if (!FunctionsList.Contains(token.Value))
{
if (FunctionsList.Contains(np))
{
token.Value = np;
}
else
{
ThrowError(ParserErrorCode.FunctionNotFound, token, token.Value);
}
}
}
token.Type = StiTokenType.Function;
}
else if (SystemVariablesList.Contains(token.Value) && (token.Value != "value"))
{
token.Type = StiTokenType.SystemVariable;
}
//else if (token.Value.ToLowerInvariant() == "true" || token.Value.ToLowerInvariant() == "false")
//{
// if (token.Value.ToLowerInvariant() == "true")
// token.ValueObject = true;
// else
// token.ValueObject = false;
// token.Type = StiTokenType.Number;
//}
//else if (token.Value.ToLowerInvariant() == "null")
//{
// token.ValueObject = null;
// token.Type = StiTokenType.Number;
//}
else if (ConstantsList.Contains(token.Value))
{
while (ConstantsList[token.Value] == namespaceObj)
{
if (tokenPos + 1 >= tokensList.Count)
{
ThrowError(ParserErrorCode.UnexpectedEndOfExpression);
}
string oldTokenValue = token.Value;
token.Value += "." + tokensList[tokenPos + 1].Value;
tokenPos += 2;
if (!ConstantsList.Contains(token.Value))
{
ThrowError(ParserErrorCode.ItemDoesNotContainDefinition, token, oldTokenValue, tokensList[tokenPos + 1].Value);
}
}
token.ValueObject = ConstantsList[token.Value];
token.Type = StiTokenType.Number;
}
else if (UserFunctionsList.Contains(token.Value))
{
token.Type = StiTokenType.Function;
}
else
{
ThrowError(ParserErrorCode.NameDoesNotExistInCurrentContext, token, token.Value);
}
}
newList.Add(token);
}
return(newList);
}
/// <summary>
/// Creates a new <see cref="DataSet"/> from the binary reader provided.
/// </summary>
/// <param name="dataSet">The data set to be loaded with data from the reader</param>
/// <param name="reader">
/// Reader connected to the source data structure and positioned to start reading
/// </param>
/// <param name="init">
/// True to indicate that the data set should be fulling initialised
/// </param>
/// <para>
/// A <see cref="DataSet"/> is constructed using the reader to retrieve
/// the header information. This is then passed to the Read methods to create the
/// lists before reading the data into memory. Finally it initialise is required
/// references between entities are worked out and stored.
/// </para>
internal static void Load(DataSet dataSet, Reader reader, bool init)
{
CommonFactory.LoadHeader(dataSet, reader);
var strings = new MemoryVariableList <AsciiString>(dataSet, reader, new AsciiStringFactory());
MemoryFixedList <Component> components = null;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
components = new MemoryFixedList <Component>(dataSet, reader, new ComponentFactoryV31());
break;
case BinaryConstants.FormatVersions.PatternV32:
components = new MemoryFixedList <Component>(dataSet, reader, new ComponentFactoryV32());
break;
}
var maps = new MemoryFixedList <Map>(dataSet, reader, new MapFactory());
var properties = new PropertiesList(dataSet, reader, new PropertyFactory());
var values = new MemoryFixedList <Value>(dataSet, reader, new ValueFactory());
var profiles = new MemoryVariableList <Entities.Profile>(dataSet, reader, new ProfileMemoryFactory());
MemoryFixedList <Signature> signatures = null;
MemoryFixedList <Integer> signatureNodeOffsets = null;
MemoryFixedList <Integer> nodeRankedSignatureIndexes = null;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
signatures = new MemoryFixedList <Signature>(dataSet, reader, new SignatureFactoryV31(dataSet));
break;
case BinaryConstants.FormatVersions.PatternV32:
signatures = new MemoryFixedList <Signature>(dataSet, reader, new SignatureFactoryV32(dataSet));
signatureNodeOffsets = new MemoryFixedList <Integer>(dataSet, reader, new IntegerFactory());
nodeRankedSignatureIndexes = new MemoryFixedList <Integer>(dataSet, reader, new IntegerFactory());
break;
}
var rankedSignatureIndexes = new MemoryFixedList <Integer>(
dataSet, reader, new IntegerFactory());
MemoryVariableList <Entities.Node> nodes = null;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
nodes = new MemoryVariableList <Entities.Node>(dataSet, reader, new NodeMemoryFactoryV31());
break;
case BinaryConstants.FormatVersions.PatternV32:
nodes = new MemoryVariableList <Entities.Node>(dataSet, reader, new NodeMemoryFactoryV32());
break;
}
var rootNodes = new MemoryFixedList <Entities.Node>(dataSet, reader, new RootNodeFactory());
var profileOffsets = new MemoryFixedList <ProfileOffset>(dataSet, reader, new ProfileOffsetFactory());
dataSet.Strings = strings;
dataSet._components = components;
dataSet._maps = maps;
dataSet._properties = properties;
dataSet._values = values;
dataSet.Profiles = profiles;
dataSet._signatures = signatures;
dataSet._rankedSignatureIndexes = rankedSignatureIndexes;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV32:
dataSet._signatureNodeOffsets = signatureNodeOffsets;
dataSet._nodeRankedSignatureIndexes = nodeRankedSignatureIndexes;
break;
}
dataSet.Nodes = nodes;
dataSet.RootNodes = rootNodes;
dataSet._profileOffsets = profileOffsets;
strings.Read(reader);
components.Read(reader);
maps.Read(reader);
properties.Read(reader);
values.Read(reader);
profiles.Read(reader);
signatures.Read(reader);
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV32:
signatureNodeOffsets.Read(reader);
nodeRankedSignatureIndexes.Read(reader);
break;
}
rankedSignatureIndexes.Read(reader);
nodes.Read(reader);
rootNodes.Read(reader);
profileOffsets.Read(reader);
if (init)
{
// Set references between objects.
dataSet.Init();
// The following lists will not be needed anymore
// so they can be freed.
dataSet._signatureNodeOffsets = null;
dataSet._nodeRankedSignatureIndexes = null;
// Force garbage collection as a lot of memory has been freed.
GC.Collect();
}
}
/// <summary>
/// Creates a new <see cref="DataSet"/> from the binary reader provided.
/// </summary>
/// <param name="dataSet">The data set to be loaded with data from the reader</param>
/// <param name="reader">
/// Reader connected to the source data structure and positioned to start reading
/// </param>
/// <param name="init">
/// True to indicate that the data set should be fulling initialised
/// </param>
/// <para>
/// A <see cref="DataSet"/> is constructed using the reader to retrieve
/// the header information. This is then passed to the Read methods to create the
/// lists before reading the data into memory. Finally it initialise is required
/// references between entities are worked out and stored.
/// </para>
internal static void Load(DataSet dataSet, Reader reader, bool init)
{
CommonFactory.LoadHeader(dataSet, reader);
var strings = new MemoryVariableList<AsciiString<DataSet>, DataSet>(dataSet, reader, new MemoryAsciiStringFactory());
MemoryFixedList<Component, DataSet> components = null;
switch(dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
components = new MemoryFixedList<Component, DataSet>(dataSet, reader, new ComponentFactoryV31());
break;
case BinaryConstants.FormatVersions.PatternV32:
components = new MemoryFixedList<Component, DataSet>(dataSet, reader, new ComponentFactoryV32());
break;
}
var maps = new MemoryFixedList<Map, DataSet>(dataSet, reader, new MapFactory());
var properties = new PropertiesList(dataSet, reader, new PropertyFactory());
var values = new MemoryFixedList<Value, DataSet>(dataSet, reader, new ValueFactory<DataSet>());
var profiles = new MemoryVariableList<Entities.Profile, DataSet>(dataSet, reader, new ProfileMemoryFactory());
MemoryFixedList<Signature, DataSet> signatures = null;
MemoryIntegerList signatureNodeOffsets = null;
MemoryIntegerList nodeRankedSignatureIndexes = null;
switch(dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
signatures = new MemoryFixedList<Signature, DataSet>(dataSet, reader, new SignatureFactoryV31<DataSet>(dataSet));
break;
case BinaryConstants.FormatVersions.PatternV32:
signatures = new MemoryFixedList<Signature, DataSet>(dataSet, reader, new SignatureFactoryV32<DataSet>(dataSet));
signatureNodeOffsets = new MemoryIntegerList(reader);
nodeRankedSignatureIndexes = new MemoryIntegerList(reader);
break;
}
var rankedSignatureIndexes = new MemoryIntegerList(reader);
MemoryVariableList<Entities.Node, DataSet> nodes = null;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
nodes = new MemoryVariableList<Entities.Node, DataSet>(dataSet, reader, new NodeMemoryFactoryV31());
break;
case BinaryConstants.FormatVersions.PatternV32:
nodes = new MemoryVariableList<Entities.Node, DataSet>(dataSet, reader, new NodeMemoryFactoryV32());
break;
}
var rootNodes = new MemoryFixedList<Entities.Node, DataSet>(dataSet, reader, new RootNodeFactory());
var profileOffsets = new MemoryFixedList<ProfileOffset, DataSet>(dataSet, reader, new ProfileOffsetFactory());
dataSet.Strings = strings;
dataSet._components = components;
dataSet._maps = maps;
dataSet._properties = properties;
dataSet._values = values;
dataSet.Profiles = profiles;
dataSet._signatures = signatures;
dataSet._rankedSignatureIndexes = rankedSignatureIndexes;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV32:
dataSet._signatureNodeOffsets = signatureNodeOffsets;
dataSet._nodeRankedSignatureIndexes = nodeRankedSignatureIndexes;
break;
}
dataSet.Nodes = nodes;
dataSet.RootNodes = rootNodes;
dataSet._profileOffsets = profileOffsets;
strings.Read(reader);
components.Read(reader);
maps.Read(reader);
properties.Read(reader);
values.Read(reader);
profiles.Read(reader);
signatures.Read(reader);
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV32:
signatureNodeOffsets.Read(reader);
nodeRankedSignatureIndexes.Read(reader);
break;
}
rankedSignatureIndexes.Read(reader);
nodes.Read(reader);
rootNodes.Read(reader);
profileOffsets.Read(reader);
if (init)
{
// Set references between objects.
dataSet.Init();
// The following lists will not be needed anymore
// so they can be freed.
dataSet._signatureNodeOffsets = null;
dataSet._nodeRankedSignatureIndexes = null;
// Force garbage collection as a lot of memory has been freed.
GC.Collect();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertiesListElement"/> class.
/// </summary>
public PropertiesListElement()
{
Properties = new PropertiesList(this);
}
/// <summary>
/// Load the necessary values from the data file in to the DataSet.
/// Initially, this will only load data such as file headers
/// and the smaller lists.
/// </summary>
/// <param name="dataSet">The dataset object to load in to</param>
/// <param name="cacheConfiguration">the cache configuration to use when creating the caches</param>
private static void LoadForStreaming(IndirectDataSet dataSet, Dictionary <CacheType, ICacheOptions> cacheConfiguration)
{
var reader = dataSet.Pool.GetReader();
try
{
CacheMap cacheMap = BuildCaches(cacheConfiguration);
dataSet.CacheMap = cacheMap;
reader.BaseStream.Position = 0;
CommonFactory.LoadHeader(dataSet, reader);
// ---- Create AsciiString list
var stringLoader = EntityLoaderFactory.GetLoaderFor(
new Header(reader),
cacheMap.StringCache,
dataSet,
new StreamAsciiStringFactory());
dataSet.Strings = new StreamList <AsciiString, IStreamDataSet>(stringLoader);
MemoryFixedList <Component, DataSet> components = null;
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
components = new MemoryFixedList <Component, DataSet>(
dataSet,
reader,
new ComponentFactoryV31());
break;
case BinaryConstants.FormatVersions.PatternV32:
components = new MemoryFixedList <Component, DataSet>(
dataSet,
reader,
new ComponentFactoryV32());
break;
}
dataSet._components = components;
var maps = new MemoryFixedList <Map, DataSet>(
dataSet,
reader,
new MapFactory());
dataSet._maps = maps;
var properties = new PropertiesList(
dataSet,
reader,
new PropertyFactory());
dataSet._properties = properties;
// ---- Create Value list
var valueLoader = EntityLoaderFactory.GetLoaderFor(new Header(reader),
cacheMap.ValueCache,
dataSet,
new ValueFactory <IStreamDataSet>());
dataSet._values = new StreamList <Value, IStreamDataSet>(valueLoader);
// ---- Create Profile list
var profileLoader = EntityLoaderFactory.GetLoaderFor(new Header(reader),
cacheMap.ProfileCache,
dataSet,
new ProfileStreamFactory(dataSet.Pool));
dataSet.Profiles = new StreamList <Entities.Profile, IStreamDataSet>(profileLoader);
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
// ---- Create Signature list for V31
var signatureLoaderV31 = EntityLoaderFactory.GetLoaderFor(
new Header(reader),
cacheMap.SignatureCache,
dataSet,
new SignatureFactoryV31 <IndirectDataSet>(dataSet));
dataSet._signatures = new StreamList <Signature, IndirectDataSet>(
signatureLoaderV31);
break;
case BinaryConstants.FormatVersions.PatternV32:
// ---- Create Signature list for V32
var signatureLoaderV32 = EntityLoaderFactory.GetLoaderFor(
new Header(reader),
cacheMap.SignatureCache,
dataSet,
new SignatureFactoryV32 <IndirectDataSet>(dataSet));
dataSet._signatures = new StreamList <Signature, IndirectDataSet>(
signatureLoaderV32);
dataSet._signatureNodeOffsets = new IntegerList(dataSet, reader);
dataSet._nodeRankedSignatureIndexes = new IntegerList(dataSet, reader);
break;
}
dataSet._rankedSignatureIndexes = new IntegerList(dataSet, reader);
switch (dataSet.VersionEnum)
{
case BinaryConstants.FormatVersions.PatternV31:
// ---- Create Nodes list for V31
var nodeLoaderV31 = EntityLoaderFactory.GetLoaderFor(
new Header(reader),
cacheMap.NodeCache,
dataSet,
new NodeStreamFactoryV31(dataSet.Pool));
dataSet.Nodes = new StreamList <Entities.Node, IStreamDataSet>(
nodeLoaderV31);
break;
case BinaryConstants.FormatVersions.PatternV32:
// ---- Create Nodes list for V31
var nodeLoaderV32 = EntityLoaderFactory.GetLoaderFor(
new Header(reader),
cacheMap.NodeCache,
dataSet,
new NodeStreamFactoryV32(dataSet.Pool));
dataSet.Nodes = new StreamList <Entities.Node, IStreamDataSet>(
nodeLoaderV32);
break;
}
var rootNodes = new MemoryFixedList <Entities.Node, DataSet>(
dataSet,
reader,
new RootNodeFactory());
dataSet.RootNodes = rootNodes;
var profileOffsets = new MemoryFixedList <ProfileOffset, DataSet>(
dataSet,
reader,
new ProfileOffsetFactory());
dataSet._profileOffsets = profileOffsets;
// Read into memory all the small lists which are frequently accessed.
reader.BaseStream.Position = components.Header.StartPosition;
components.Read(reader);
reader.BaseStream.Position = maps.Header.StartPosition;
maps.Read(reader);
reader.BaseStream.Position = properties.Header.StartPosition;
properties.Read(reader);
reader.BaseStream.Position = rootNodes.Header.StartPosition;
rootNodes.Read(reader);
reader.BaseStream.Position = profileOffsets.Header.StartPosition;
profileOffsets.Read(reader);
}
finally
{
dataSet.Pool.Release(reader);
}
}
