public static byte[] Serialize(this IColumnSpec columnSpec, object data) { byte[] rawData; switch (columnSpec.ColumnType) { case ColumnType.List: return(SerializeList((IList)data, value => Serialize(columnSpec.CollectionValueType, value))); case ColumnType.Set: var colType = columnSpec.CollectionValueType.ToType(); Type accessorType = typeof(HashSetAccessor <>).MakeGenericType(colType); var setAccessor = (IHashSetAccessor)Activator.CreateInstance(accessorType, data); return(SerializeSet(setAccessor, value => Serialize(columnSpec.CollectionValueType, value))); case ColumnType.Map: return(SerializeMap((IDictionary)data, key => Serialize(columnSpec.CollectionKeyType, key), value => Serialize(columnSpec.CollectionValueType, value))); default: rawData = Serialize(columnSpec.ColumnType, data); break; } return(rawData); }
/// <summary> /// Multiply two matrix with padding and repeating if dimensions don't match. /// </summary> /// <param name="left">The left matrix.</param> /// <param name="right">The right matrix.</param> /// <returns>The product of two matrix.</returns> public static INumberTable MatrixProduct(INumberTable left, INumberTable right) { int dim = right.Rows; // The dimension of the transformation. int repeats = left.Columns / dim; if (left.Columns % dim > 0) { repeats++; } int outColumns = repeats * right.Columns; INumberTable prod = WaveTransforms.App.ScriptApp.New.NumberTable(left.Rows, outColumns); double[][] P = (double[][])prod.Matrix; double[][] L = (double[][])left.Matrix; double[][] R = (double[][])right.Matrix; for (int row = 0; row < prod.Rows; row++) { double[] Lrow = L[row]; for (int col = 0; col < prod.Columns; col++) { int col2 = col % right.Columns; int k0 = col / right.Columns * dim; double v = 0; for (int k = 0; k < dim; k++) { if ((k0 + k) < Lrow.Length) { v += Lrow[k0 + k] * R[k][col2]; } } P[row][col] = v; } } for (int row = 0; row < left.Rows; row++) { prod.RowSpecList[row].CopyFrom(left.RowSpecList[row]); } IList <IColumnSpec> pSpecList = prod.ColumnSpecList; IList <IColumnSpec> rSpecList = right.ColumnSpecList; for (int col = 0; col < prod.Columns; col++) { IColumnSpec cs = pSpecList[col]; cs.CopyFrom(rSpecList[col % right.Columns]); int n = col / right.Columns; if (n > 0) { cs.Id += "_" + n; } } return(prod); }
internal static IObservable<object> CreateExecuteQuery(IConnection connection, byte[] id, IColumnSpec[] columnSpecs, ConsistencyLevel cl, ExecutionFlags executionFlags, string cql, IDataMapperFactory factory) { Action<IFrameWriter> writer = fw => WriteExecuteRequest(fw, id, columnSpecs, cl, factory); Func<IFrameReader, IEnumerable<object>> reader = fr => ReadRowSet(fr, factory); InstrumentationToken token = InstrumentationToken.Create(RequestType.Prepare, executionFlags, cql); Query query = new Query(writer, reader, token, connection); return query; }
protected static IColumnSpec[] ReadColumnSpec(IFrameReader frameReader) { Stream stream = frameReader.ReadOnlyStream; MetadataFlags flags = (MetadataFlags)stream.ReadInt(); bool globalTablesSpec = 0 != (flags & MetadataFlags.GlobalTablesSpec); int colCount = stream.ReadInt(); string keyspace = null; string table = null; if (globalTablesSpec) { keyspace = stream.ReadString(); table = stream.ReadString(); } IColumnSpec[] columnSpecs = new IColumnSpec[colCount]; for (int colIdx = 0; colIdx < colCount; ++colIdx) { string colKeyspace = keyspace; string colTable = table; if (!globalTablesSpec) { colKeyspace = stream.ReadString(); colTable = stream.ReadString(); } string colName = stream.ReadString(); ColumnType colType = (ColumnType)stream.ReadUShort(); string colCustom = null; ColumnType colKeyType = ColumnType.Custom; ColumnType colValueType = ColumnType.Custom; switch (colType) { case ColumnType.Custom: colCustom = stream.ReadString(); break; case ColumnType.List: case ColumnType.Set: colValueType = (ColumnType)stream.ReadUShort(); break; case ColumnType.Map: colKeyType = (ColumnType)stream.ReadUShort(); colValueType = (ColumnType)stream.ReadUShort(); break; } columnSpecs[colIdx] = new ColumnSpec(colIdx, colKeyspace, colTable, colName, colType, colCustom, colKeyType, colValueType); } return(columnSpecs); }
public void Set(IColumnSpec columnSpec, object data) { if (null == data) return; if (! TrySet(columnSpec.Name, data)) { if (columnSpec.Name.Contains("_")) { string newName = columnSpec.Name.Replace("_", ""); TrySet(newName, data); } } }
public bool Set(IColumnSpec columnSpec, object data) { if (TrySet(columnSpec.Name, data)) { return true; } if (columnSpec.Name.Contains("_")) { string newName = columnSpec.Name.Replace("_", ""); return TrySet(newName, data); } return false; }
public ColumnSpec(IColumnSpec columnSpec) { if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)base.ObfuscationStrategySpec != null && (object)columnSpec.ObfuscationStrategySpec != null) { foreach (KeyValuePair <string, object> keyValuePair in columnSpec.ObfuscationStrategySpec) { base.ObfuscationStrategySpec.Add(keyValuePair.Key, keyValuePair.Value); } } this.ColumnName = columnSpec.ColumnName; this.ObfuscationStrategyType = columnSpec.ObfuscationStrategyType; }
public static object Deserialize(this IColumnSpec columnSpec, byte[] rawData) { object data; Type colType; switch (columnSpec.ColumnType) { default: data = Deserialize(columnSpec.ColumnType, rawData); break; case ColumnType.List: colType = columnSpec.CollectionValueType.ToType(); Type typedColl = typeof(List <>).MakeGenericType(columnSpec.CollectionValueType.ToType()); IList list = (IList)Activator.CreateInstance(typedColl); return(DeserializeList(rawData, list, value => Deserialize(columnSpec.CollectionValueType, value))); case ColumnType.Map: colType = columnSpec.CollectionValueType.ToType(); var colKeyType = columnSpec.CollectionKeyType.ToType(); Type typedDic = typeof(Dictionary <,>).MakeGenericType(colKeyType, colType); IDictionary dic = (IDictionary)Activator.CreateInstance(typedDic); return(DeserializeMap(rawData, dic, key => Deserialize(columnSpec.CollectionKeyType, key), val => Deserialize(columnSpec.CollectionValueType, val))); case ColumnType.Set: colType = columnSpec.CollectionValueType.ToType(); Type typedSet = typeof(HashSet <>).MakeGenericType(colType); object hashSet = Activator.CreateInstance(typedSet); Type accessorType = typeof(HashSetAccessor <>).MakeGenericType(colType); var setAccessor = (IHashSetAccessor)Activator.CreateInstance(accessorType, hashSet); DeserializeSet(rawData, setAccessor, val => Deserialize(columnSpec.CollectionValueType, val)); return(hashSet); } return(data); }
public object Get(IColumnSpec columnSpec) { object res; string name = columnSpec.Name; if (TryGet(name, out res)) { return res; } if (name.Contains("_")) { name = name.Replace("_", ""); if (TryGet(name, out res)) { return res; } } throw new ArgumentException("Can't find requested member", columnSpec.Name); }
public object GetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec columnSpec, IField field, object originalFieldValue) { IColumnSpec <TObfuscationStrategySpec> _columnSpec; object value; if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)originalFieldValue == DBNull.Value) { originalFieldValue = null; } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } _columnSpec = new ColumnSpec <TObfuscationStrategySpec>(columnSpec); if ((object)_columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(_columnSpec.ObfuscationStrategySpec))); } value = this.CoreGetObfuscatedValue(obfuscationContext, _columnSpec, field, originalFieldValue); return(value); }
protected static IColumnSpec[] ReadColumnSpecs(int colCount, string keyspace, string table, bool globalTablesSpec, Stream stream) { IColumnSpec[] columnSpecs = new IColumnSpec[colCount]; for (int colIdx = 0; colIdx < colCount; ++colIdx) { string colKeyspace = keyspace; string colTable = table; if (!globalTablesSpec) { colKeyspace = stream.ReadString(); colTable = stream.ReadString(); } string colName = stream.ReadString(); ColumnType colType = (ColumnType)stream.ReadUShort(); string colCustom = null; ColumnType colKeyType = ColumnType.Custom; ColumnType colValueType = ColumnType.Custom; switch (colType) { case ColumnType.Custom: colCustom = stream.ReadString(); break; case ColumnType.List: case ColumnType.Set: colValueType = (ColumnType)stream.ReadUShort(); break; case ColumnType.Map: colKeyType = (ColumnType)stream.ReadUShort(); colValueType = (ColumnType)stream.ReadUShort(); break; } columnSpecs[colIdx] = new ColumnSpec(colIdx, colKeyspace, colTable, colName, colType, colCustom, colKeyType, colValueType); } return(columnSpecs); }
private static IEnumerable<object> ReadRows(IFrameReader frameReader, IColumnSpec[] columnSpecs, IDataMapperFactory mapperFactory) { Stream stream = frameReader.ReadOnlyStream; int rowCount = stream.ReadInt(); for (int rowIdx = 0; rowIdx < rowCount; ++rowIdx) { IInstanceBuilder instanceBuilder = mapperFactory.CreateBuilder(); foreach (ColumnSpec colSpec in columnSpecs) { byte[] rawData = stream.ReadByteArray(); object data = null != rawData ? colSpec.Deserialize(rawData) : null; instanceBuilder.Set(colSpec, data); } yield return instanceBuilder.Build(); } }
private static void WriteExecuteRequest(IFrameWriter frameWriter, byte[] id, IColumnSpec[] columnSpecs, ConsistencyLevel cl, IDataMapperFactory factory) { Stream stream = frameWriter.WriteOnlyStream; stream.WriteShortByteArray(id); stream.WriteShort((short) columnSpecs.Length); IDataSource dataSource = factory.DataSource; foreach (IColumnSpec columnSpec in columnSpecs) { object data = dataSource.Get(columnSpec); byte[] rawData = columnSpec.Serialize(data); stream.WriteByteArray(rawData); } stream.WriteShort((short) cl); frameWriter.SetMessageType(MessageOpcodes.Execute); }
public bool ImportFile0(string fileName) { IVisuMap app = CustomImporter.App.ScriptApp; if (!fileName.ToLower().EndsWith(".fcs")) { return(false); // Let other import handle it. } INumberTable dataTable = null; IFreeTable textTable = null; bool compensated = false; bool logScaled = false; using (StreamReader sr = new StreamReader(fileName)) { // // Read the text segment. // char[] header = new char[42]; sr.ReadBlock(header, 0, header.Length); int textBegin = int.Parse(new string(header, 10, 8)); int textEnd = int.Parse(new string(header, 18, 8)); int beginData = int.Parse(new string(header, 26, 8)); int endData = int.Parse(new string(header, 34, 8)); char[] line = new char[textEnd + 4]; sr.ReadBlock(line, header.Length, line.Length - header.Length); string textSeg = new string(line, textBegin + 1, textEnd - textBegin); char delimiter = line[textBegin]; textTable = app.New.FreeTable(); textTable.AddColumn("Value", false); string[] textFields = textSeg.Split(delimiter); textTable.AddRows("P", textFields.Length / 2); IList <IRowSpec> rowSpecList = textTable.RowSpecList; for (int row = 0; row < textTable.Rows; row++) { rowSpecList[row].Id = textFields[2 * row]; textTable.Matrix[row][0] = textFields[2 * row + 1]; } // // Read in the data segement // fcsInfo = new FcsInfo(textTable, header); if ((beginData == 0) && (textTable.IndexOfRow("$BEGINDATA") > 0)) { beginData = int.Parse(textTable.Matrix[textTable.IndexOfRow("$BEGINDATA")][0]); } if ((endData == 0) && (textTable.IndexOfRow("$ENDDATA") > 0)) { endData = int.Parse(textTable.Matrix[textTable.IndexOfRow("$ENDDATA")][0]); } dataTable = app.New.NumberTable(fcsInfo.Rows, fcsInfo.Columns); using (BinaryReader br = new BinaryReader(sr.BaseStream)) { br.BaseStream.Seek(beginData, SeekOrigin.Begin); Byte[] buf4 = new byte[4]; Byte[] buf8 = new byte[8]; int bitOffset = 0; for (int row = 0; row < fcsInfo.Rows; row++) { for (int col = 0; col < fcsInfo.Columns; col++) { ColumnInfo ci = fcsInfo.ColumnInfo[col]; Byte[] data = ReadBits(br, ci.Bits, ref bitOffset); if (data.Length < ci.Bytes) { row = fcsInfo.Rows; // enforce premature loop-end. break; } Byte[] buf = (fcsInfo.DataType == FcsInfo.DataTypes.Double) ? buf8 : buf4; Array.Clear(buf, 0, buf.Length); Array.Copy(data, 0, buf, 0, ci.Bytes); if (!fcsInfo.BigEndian) { // Intel CPU expects BigEndian format. Array.Reverse(buf, 0, ci.Bytes); } switch (fcsInfo.DataType) { case FcsInfo.DataTypes.Integer: dataTable.Matrix[row][col] = (BitConverter.ToUInt32(buf, 0) & ci.RangeMask); break; case FcsInfo.DataTypes.Float: dataTable.Matrix[row][col] = BitConverter.ToSingle(buf, 0); break; case FcsInfo.DataTypes.Double: dataTable.Matrix[row][col] = BitConverter.ToDouble(buf, 0); break; } } } } } // Post processing for (int col = 0; col < fcsInfo.Columns; col++) { IColumnSpec cs = dataTable.ColumnSpecList[col]; ColumnInfo cInfo = fcsInfo.ColumnInfo[col]; cs.Id = cInfo.ShortName; //cs.Name = cInfo.Name + ( cInfo.IsLinear ? ".Lin" : ".Log"); cs.Name = cInfo.Name; if ((cs.Id == "TIME") || (cs.Id == "TIME1")) { int timeStepIdx = textTable.IndexOfRow("$TIMESTEP"); if (timeStepIdx >= 0) { double timeStep = double.Parse(textTable.Matrix[timeStepIdx][0]); for (int row = 0; row < fcsInfo.Rows; row++) { dataTable.Matrix[row][col] *= timeStep; } } } } IList <IRowSpec> rSpecList = dataTable.RowSpecList; for (int row = 0; row < fcsInfo.Rows; row++) { rSpecList[row].Id = row.ToString(); } FileInfo fInfo = new FileInfo(fileName); string shortName = fInfo.Name.Substring(0, fInfo.Name.LastIndexOf('.')); if (saveMetaInfo >= 1) { SaveParameterTable(textTable, shortName); if (saveMetaInfo >= 2) { textTable.SaveAsDataset(shortName + " (Text Seg)", "Text segement of data table " + shortName); } } if (autoCompensation) { try { string sMatrix = null; for (int i = 0; i < textTable.Rows; i++) { string id = textTable.RowSpecList[i].Id.ToLower(); if (id.StartsWith("$")) { id = id.Substring(1); } if ((id == "spill") || (id == "spillover")) { sMatrix = textTable.Matrix[i][0]; break; } } if (sMatrix == null) { throw new Exception(""); // silently ignore compensation as no compensation matrix available. } string[] fs = sMatrix.Split(','); int dimension = int.Parse(fs[0]); if (fs.Length != (dimension * dimension + dimension + 1)) { throw new Exception("Invalid spill over matrix."); } INumberTable cMatrix = app.New.NumberTable(dimension, dimension); List <string> parList = fs.Skip(1).Take(dimension).ToList(); int idx; if (parList.Count(id => int.TryParse(id, out idx)) == parList.Count) { // The columns are specified by a list of indexes. We convert them here to ids for (int i = 0; i < parList.Count; i++) { parList[i] = dataTable.ColumnSpecList[int.Parse(parList[i]) - 1].Id; // index starts with 1 ! } } for (int col = 0; col < cMatrix.Columns; col++) { cMatrix.ColumnSpecList[col].Id = parList[col]; } int fsIdx = dimension + 1; for (int row = 0; row < cMatrix.Rows; row++) { for (int col = 0; col < cMatrix.Columns; col++) { cMatrix.Matrix[row][col] = double.Parse(fs[fsIdx++]); } } var cData = dataTable.SelectColumnsById(parList); if (cData.Columns != parList.Count) { if (dataTable.ColumnSpecList.Count(cl => cl.Id.Equals("<" + parList[0] + ">")) == 1) { // siliently ignore aready compensated data. throw new Exception(""); } else { throw new Exception("Invalid spill over matrix: unknown names."); } } var math = CustomImporter.App.GetMathAdaptor(); var m = math.InvertMatrix((double[][])cMatrix.Matrix); for (int row = 0; row < cMatrix.Rows; row++) { cMatrix.Matrix[row] = m[row]; } cData = cData.Multiply(cMatrix); // perform the comensation with the inverse matrix of the spill over matrix. cData.CopyValuesTo(dataTable); compensated = true; } catch (Exception ex) { if (ex.Message != "") { MessageBox.Show("Cannot perform compensation: " + ex.Message); } } } if (logTransform) { double[][] m = (double[][])dataTable.Matrix; double T = 262144; double W = 1.0; double M = 4.5; string[] settings = app.GetProperty( "CustomImporter.Logicle.Settings", "262144; 1.0; 4.5").Split(';'); if (settings.Length == 3) { double.TryParse(settings[0], out T); double.TryParse(settings[1], out W); double.TryParse(settings[2], out M); } var fastLogicle = new VisuMap.DataCleansing.FastLogicle(T, W, M); double maxVal = fastLogicle.MaxValue; double minVal = fastLogicle.MinValue; for (int col = 0; col < fcsInfo.Columns; col++) { if (fcsInfo.ColumnInfo[col].LogTrans) { for (int row = 0; row < fcsInfo.Rows; row++) { m[row][col] = M * fastLogicle.scale(Math.Min(maxVal, Math.Max(minVal, m[row][col]))); } logScaled = true; } } } string msg = "Dataset imported from " + fileName + ". Version: " + fcsInfo.version; if (compensated) { msg += ", compensated"; } if (logScaled) { msg += ", log-scaled"; } string dsName = dataTable.SaveAsDataset(shortName, msg); app.Folder.OpenDataset(dsName); INumberTable nTable = app.GetNumberTable(); List <IColumnSpec> csList = nTable.ColumnSpecList as List <IColumnSpec>; int fsc = csList.FindIndex(cs => cs.Id == "FSC-A"); int ssc = csList.FindIndex(cs => cs.Id == "SSC-A"); if ((fsc >= 0) && (ssc >= 0)) { var xy = app.New.XyPlot(nTable); xy.Show(); xy.XAxisIndex = fsc; xy.YAxisIndex = ssc; xy.AutoScaling = true; xy.Redraw(); xy.CaptureMap(); xy.Close(); app.Map.Name = "FSC/SSC"; } else { // We just do create a simple PCA view. IPcaView pca = nTable.ShowPcaView(); pca.ResetView(); pca.CaptureMap(); app.Map.Redraw(); pca.Close(); app.Map.Name = "PCA-All"; } app.Map.GlyphType = glyphName; app.Map.Redraw(); if (showResult) { app.New.SpectrumBand(nTable).Show(); } fcsInfo = null; return(true); }
public void Set(IColumnSpec columnSpec, object data) { _data[columnSpec.Name] = data; }
protected override object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <Spec> columnSpec, IField field, object columnValue) { Type valueType; string _columnValue; long surrogateKey; object surrogateValue; IDictionarySpec dictionarySpec; if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } if ((object)columnValue == null) { return(null); } valueType = columnValue.GetType(); if (valueType != typeof(string)) { return(null); } _columnValue = (string)columnValue; _columnValue = _columnValue.Trim(); if (SolderFascadeAccessor.DataTypeFascade.IsWhiteSpace(_columnValue)) { return(_columnValue); } dictionarySpec = columnSpec.ObfuscationStrategySpec.DictionarySpec; if ((object)dictionarySpec == null) { throw new InvalidOperationException(string.Format("Failed to obtain dictionary.")); } if ((dictionarySpec.RecordCount ?? 0L) <= 0L) { return(null); } surrogateKey = obfuscationContext.GetValueHash(dictionarySpec.RecordCount, columnValue); if (!obfuscationContext.TryGetSurrogateValue(dictionarySpec, surrogateKey, out surrogateValue)) { throw new InvalidOperationException(string.Format("Failed to obtain surrogate value.")); } return(surrogateValue); }
protected override object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <Spec> columnSpec, IField field, object columnValue) { if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } return(columnValue); }
private static IColumnSpec[] ReadColumnSpec(IFrameReader frameReader) { Stream stream = frameReader.ReadOnlyStream; MetadataFlags flags = (MetadataFlags) stream.ReadInt(); bool globalTablesSpec = 0 != (flags & MetadataFlags.GlobalTablesSpec); int colCount = stream.ReadInt(); string keyspace = null; string table = null; if (globalTablesSpec) { keyspace = stream.ReadString(); table = stream.ReadString(); } IColumnSpec[] columnSpecs = new IColumnSpec[colCount]; for (int colIdx = 0; colIdx < colCount; ++colIdx) { string colKeyspace = keyspace; string colTable = table; if (!globalTablesSpec) { colKeyspace = stream.ReadString(); colTable = stream.ReadString(); } string colName = stream.ReadString(); ColumnType colType = (ColumnType) stream.ReadShort(); string colCustom = null; ColumnType colKeyType = ColumnType.Custom; ColumnType colValueType = ColumnType.Custom; switch (colType) { case ColumnType.Custom: colCustom = stream.ReadString(); break; case ColumnType.List: case ColumnType.Set: colValueType = (ColumnType) stream.ReadShort(); break; case ColumnType.Map: colKeyType = (ColumnType) stream.ReadShort(); colValueType = (ColumnType) stream.ReadShort(); break; } columnSpecs[colIdx] = new ColumnSpec(colIdx, colKeyspace, colTable, colName, colType, colCustom, colKeyType, colValueType); } return columnSpecs; }
public PreparedQuery(IConnection connection, byte[] id, IColumnSpec[] columnSpecs) { _connection = connection; _id = id; _columnSpecs = columnSpecs; }
public object Get(IColumnSpec columnSpec) { return _dataSource[columnSpec.Index]; }
protected override object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <Spec> columnSpec, IField field, object columnValue) { object value; double maskingFactor; if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } maskingFactor = (columnSpec.ObfuscationStrategySpec.MaskingPercentValue.GetValueOrDefault() / 100.0); value = GetMask(maskingFactor, columnValue); return(value); }
public ColumnData(IColumnSpec spec, byte[] rawData) { ColumnSpec = spec; RawData = rawData; }
protected override object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <Spec> columnSpec, IField field, object columnValue) { long signHash, valueHash; object value; double varianceFactor; if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } signHash = obfuscationContext.GetSignHash(columnValue); valueHash = obfuscationContext.GetValueHash(columnSpec.ObfuscationStrategySpec.VariancePercentValue, columnValue); varianceFactor = ((((valueHash <= 0 ? 1 : valueHash)) * ((signHash % 2 == 0 ? 1.0 : -1.0))) / 100.0); value = GetVariance(varianceFactor, columnValue); return(value); }
public ColumnData(IColumnSpec spec, byte[] rawData) { ColumnSpec = spec; RawData = rawData; }
protected override object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <Spec> columnSpec, IField field, object columnValue) { object value; if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } //value = GetDefault(field.IsOptional && (columnSpec.ObfuscationStrategySpec.DefaultingCanBeNull ?? false), field.FieldType); value = null; return(value); }
protected override object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <Spec> columnSpec, IField field, object columnValue) { long valueHash; object value; long randomSeed; if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } valueHash = obfuscationContext.GetValueHash(null, columnValue); randomSeed = valueHash; value = GetShuffle(randomSeed, columnValue); return(value); }
protected override object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <Spec> columnSpec, IField field, object columnValue) { long signHash, valueHash; object value; string sharedSecret; if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } signHash = obfuscationContext.GetSignHash(columnValue); valueHash = obfuscationContext.GetValueHash(null, columnValue); sharedSecret = ((valueHash <= 0 ? 1 : valueHash) * (signHash % 2 == 0 ? -1 : 1)).ToString("X"); value = GetCipher(sharedSecret, columnValue); return(value); }
protected override object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <Spec> columnSpec, IField field, object columnValue) { long valueHash; object value; long randomSeed; if ((object)obfuscationContext == null) { throw new ArgumentNullException(nameof(obfuscationContext)); } if ((object)columnSpec == null) { throw new ArgumentNullException(nameof(columnSpec)); } if ((object)field == null) { throw new ArgumentNullException(nameof(field)); } if ((object)columnSpec.ObfuscationStrategySpec == null) { throw new InvalidOperationException(string.Format("Specification missing: '{0}'.", nameof(columnSpec.ObfuscationStrategySpec))); } valueHash = obfuscationContext.GetValueHash(null, field.FieldName); randomSeed = valueHash; // create a new repeatable yet random-ish math funcion using the random seed, then executes for column value value = GetSurrogateKey(randomSeed, columnValue); return(value); }
public bool Set(IColumnSpec columnSpec, object data) { _data[columnSpec.Name] = data; return true; }
protected abstract object CoreGetObfuscatedValue(IObfuscationContext obfuscationContext, IColumnSpec <TObfuscationStrategySpec> columnSpec, IField field, object columnValue);