private List <KeyValue> GetListHashValue(Key key, object data)
{
if (!(data is object[]))
{
return(null);
}
List <object> rt = new List <object>();
object[] array = (object[])data;
for (int i = 0; i < array.Length; i++)
{
object d = array[i];
List <KeyValue> temp = GetChildrenKeyValue(key, d);
if (temp == null || temp.Count == 0)
{
continue;
}
rt.Add(RebuildRowChildData(temp));
}
KeyValue t = new KeyValue();
t.Add(key.Name, rt);
return(new List <KeyValue>()
{
t
});
}
public bool Add(TKey key)
{
if (_internalCollection.ContainsKey(key))
{
return(false);
}
_internalCollection.Add(key, new Empty());
return(true);
}
public T Load <T>(string key, T defaultval)
{
if (Contains(key))
{
return((T)Convert.ChangeType(KeyValue[key], typeof(T)));
}
KeyValue.Add(key, default(T));
LookupTable.Add(key);
return(defaultval);
}
public void Add(K key, V value)
{
key.ValidateNotNull("The key is null!");
value.ValidateNotNull("The value is null!");
if (KeyValue.ContainsKey(key))
{
throw new ArgumentException("The key already exists in the bimap.");
}
if (ValueKey.ContainsKey(value))
{
throw new ArgumentException("The value already exists in the bimap.");
}
KeyValue.Add(key, value);
ValueKey.Add(value, key);
}
public T MagicLoad <T>([CallerMemberName] string key = null)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (Contains(key))
{
return((T)Convert.ChangeType(KeyValue[key], typeof(T)));
}
KeyValue.Add(key, default(T));
LookupTable.Add(key);
return(default(T));
}
/// <summary>Writes a value using the specified value to the specified key.</summary>
/// <param name="key">The key containg the value.</param>
/// <param name="value">The value to write.</param>
public void Save(string key, object value)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (Contains(key))
{
KeyValue[key] = value;
}
else
{
LookupTable.Add(key);
KeyValue.Add(key, value);
}
}
/// <summary>Writes a value to the specified key (caller).</summary>
/// <param name="value">The value to write.</param>
/// <param name="caller">The calling member to write as key.</param>
public void MagicSave(object value, [CallerMemberName] string caller = null)
{
if (caller == null)
{
throw new ArgumentNullException(nameof(caller));
}
if (Contains(caller))
{
KeyValue[caller] = value;
}
else
{
LookupTable.Add(caller);
KeyValue.Add(caller, value);
}
}
/// <summary>Generates the file for handling in memory.</summary>
public void Generate()
{
using (var stream = File.OpenText(Filename))
{
while (!stream.EndOfStream)
{
var line = stream.ReadLine();
if (line == null)
{
continue;
}
var keyvalue = line.Split(new[] { Splitter }, StringSplitOptions.RemoveEmptyEntries);
if (keyvalue.Length < 2)
{
continue;
}
KeyValue.Add(keyvalue[0], keyvalue[1]);
LookupTable.Add(keyvalue[0]);
}
}
}
public DataRow(
Entity entity)
: this()
{
foreach (var key in entity.Key)
{
KeyValue.Add(key.Value.AsString);
}
foreach (var linkKey in entity.LinkKey)
{
LinkKeyValue.Add(linkKey.Value.AsString);
}
foreach (var property in entity.DisplayProperties)
{
Values.Add(new CellValue
{
Raw = property.Value.Raw,
Property = property
});
}
}
private List <KeyValue> GetItemKeyValue(HashMap hash, Key key)
{
object data;
if (!hash.TryGetValue(key.Name, out data))
{
return(null);
}
if (key.Children.Count == 0)
{
KeyValue kv = new KeyValue();
kv.Add(key.Name, data);
return(new List <KeyValue>()
{
kv
});
}
List <KeyValue> list = GetListHashValue(key, data);
return(list ?? GetChildrenKeyValue(key, data));
}
internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
{
if (id == "closed")
{
Closed = parser.ParseBoolValue();
}
else if (id == "key")
{
Key.AddRange(parser.ParseSFFloatOrMFFloatValue());
}
else if (id == "keyValue")
{
List <double> values = parser.ParseSFFloatOrMFFloatValue();
foreach (double value in values)
{
KeyValue.Add(new SFFloat(value));
}
}
else if (id == "keyVelocity")
{
List <double> values = parser.ParseSFFloatOrMFFloatValue();
foreach (double value in values)
{
KeyVelocity.Add(new SFFloat(value));
}
}
else if (id == "normalizeVelocity")
{
NormalizeVelocity = parser.ParseBoolValue();
}
else
{
return(false);
}
return(true);
}
public DataRow(
IDictionary <String, object> recordDict,
Entity entity,
string prefix = null)
: this()
{
foreach (var key in entity.Key)
{
KeyValue.Add(recordDict[prefix + key.ColumnName.Undecorate()].ToStringSafe());
}
foreach (var linkKey in entity.LinkKey)
{
LinkKeyValue.Add(recordDict[prefix + linkKey.ColumnName.Undecorate()].ToStringSafe());
}
foreach (var property in entity.DisplayProperties)
{
Values.Add(new CellValue
{
Raw = recordDict[prefix + property.ColumnName.Undecorate()],
Property = property
});
}
}
