public Action(byte address, CSet cmd)
{
m_adr = address;
m_cmd = cmd;
m_PanSpeed = 0xFF;
m_TiltSpeed = 0xFF;
}
public void CreateExcel(CSet dataset)
{
Application excelApp = new Application();
Workbook workbook = workbook = excelApp.Workbooks.Add(Type.Missing);
for (int i = 0; i < dataset.CTables.Count; i++)
{
CelCalc celCalc = new CelCalc(dataset.CTables[i]);
Worksheet worksheet = null;
if (i == 0)
{
worksheet = (Worksheet)workbook.ActiveSheet;
}
else
{
worksheet = (Worksheet)workbook.Worksheets.Add(After: workbook.ActiveSheet);
}
// Get the Starting Position of the record table
Coordinates co = celCalc.GetTableStartingPosition();
worksheet.Name = dataset.CTables[i].TabName;
// Header of the Title of the Sheet
if (dataset.CTables[i].Header != null && dataset.CTables[i].Header != "")
{
Coordinates hCo = celCalc.GetSheetHeaderStartingPosition();
Range headerSpan = worksheet.Range[worksheet.Cells[hCo.Row, hCo.Column], worksheet.Cells[hCo.Row, hCo.Column + CellPosition.HeaderSpan]];
headerSpan.Merge();
headerSpan.HorizontalAlignment = XlHAlign.xlHAlignCenter;
headerSpan.Font.Size = CellPosition.SheetHeaderFontSize;
headerSpan.Font.Bold = true;
headerSpan.Font.Color = SheetHeaderColor.sheetHeaderColor;
headerSpan.Value = dataset.CTables[i].Header;
headerSpan.Borders.ThemeColor = System.Drawing.Color.Aqua;
}
for (int j = 0; j < dataset.CTables[i].CRows.Count; j++)
{
for (int k = 0; k < dataset.CTables[i].CRows[j].Datarow.Count; k++)
{
worksheet.Cells[(co.Row + j), (k + 1)] = dataset.CTables[i].CRows[j].Datarow[k];
Range rRange = worksheet.Range[worksheet.Cells[co.Row + j, k + co.Column], worksheet.Cells[co.Row + j, dataset.CTables[i].CRows[j].Datarow.Count]];
rRange.Font.Size = CellPosition.TableRecordFontSize;
}
// Header Row
Range r = worksheet.Range[worksheet.Cells[co.Row, co.Column], worksheet.Cells[co.Row, dataset.CTables[i].CRows[j].Datarow.Count]];
r.Font.Size = CellPosition.TableHeaderFontSize;
r.Font.Bold = true;
}
// Full Table Border & Alignment set
Range fullRange = worksheet.Range[worksheet.Cells[co.Row, co.Column], worksheet.Cells[dataset.CTables[i].CRows.Count + co.Row - 1, dataset.CTables[i].CRows[1].Datarow.Count]];
fullRange.Borders.LineStyle = XlLineStyle.xlContinuous;
fullRange.HorizontalAlignment = XlHAlign.xlHAlignCenter;
fullRange.Columns.ColumnWidth = CellPosition.ColumnWidth;
}
excelApp.DisplayAlerts = false;
workbook.SaveAs(destinationFileLocation,
Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
Microsoft.Office.Interop.Excel.XlSaveAsAccessMode.xlNoChange, Type.Missing, Type.Missing, Type.Missing,
Type.Missing, Type.Missing);
workbook.Close();
excelApp.Quit();
}
public Action(byte address, CSet cmd, byte panspeed, byte tiltspeed)
{
m_adr = address;
m_cmd = cmd;
m_PanSpeed = panspeed;
m_TiltSpeed = tiltspeed;
}
static void Main(string[] args)
{
var data = File.OpenRead(XUtil.sourceFileLocation);
StreamReader reader = new StreamReader(data);
string json = reader.ReadToEnd();
CSet cs = JsonConvert.DeserializeObject <CSet>(json);
XUtil xUtil = new XUtil();
xUtil.CreateExcel(cs);
}
public CSet Intersection(CSet aSet)
{
CSet tempSet = new CSet();
for (int i = 0; i <= data.Count - 1; i++)
{
tempSet.data[i] = (this.data[i] & aSet.data[i]);
}
return(tempSet);
}
public CSet Difference(CSet aSet)
{
CSet tempSet = new CSet();
for (int i = 0; i <= data.Count - 1; i++)
{
tempSet.data[i] = (this.data[i] & (!(aSet.data[i])));
}
return(tempSet);
}
public void AddAndRemovedEntriesFromDictionary()
{
var storage = new InMemoryStorageEngine();
var os = ObjectStore2.New(storage);
var s = new CSet <Person>();
os.Roots.Entangle(s);
var peter = new Person {
Name = "Peter"
};
var ole = new Person {
Name = "Ole", Relationship = peter
};
s.Add(peter);
s.Add(ole);
os.Persist();
os = ObjectStore2.Load(storage);
s = os.Roots.Find <CSet <Person> >();
s.Count.ShouldBe(2);
peter = s.Single(p => p.Name == "Peter");
ole = s.Single(p => p.Name == "Ole");
ole.Relationship.ShouldBe(peter);
s.Remove(ole);
os.Persist();
os = ObjectStore2.Load(storage);
s = os.Roots.Find <CSet <Person> >();
s.Count.ShouldBe(1);
peter = s.Single(p => p.Name == "Peter");
s.Add(peter);
s.Count.ShouldBe(1);
os.Persist();
os = ObjectStore2.Load(storage);
s = os.Roots.Find <CSet <Person> >();
s.Count.ShouldBe(1);
peter = s.Single(p => p.Name == "Peter");
s.Remove(peter);
os.Persist();
os = ObjectStore2.Load(storage);
s = os.Roots.Find <CSet <Person> >();
s.Count.ShouldBe(0);
}
public override bool Equals(Object item)
{
if (item == null || GetType() != item.GetType())
{
return(false);
}
CSet temp = (CSet)item;
return(Title == temp.Title && quantity == temp.quantity);
}
public bool isSubset(CSet aSet)
{
for (int i = 0; i <= data.Count - 1; i++)
{
if (this.data[i] & (!(aSet.data[i])))
{
return(false);
}
}
return(true);
}
public CSet Intersection(CSet aSet)
{
CSet tempSet = new CSet();
foreach (Object hashObject in data.Keys)
{
if (aSet.data.Contains(hashObject))
{
tempSet.Add(aSet.data[hashObject]);
}
}
return(tempSet);
}
public CSet Difference(CSet aSet)
{
CSet tempSet = new CSet();
foreach (Object hashObject in data.Keys)
{
if (!(aSet.data.Contains(hashObject)))
{
tempSet.Add(data[hashObject]);
}
}
return(tempSet);
}
public void ElementsAddedToListAreAddedToStateMap()
{
var set = new CSet <int> {
0, 1
};
AttachAndPersist(set);
set = Load <CSet <int> >();
set.Count.ShouldBe(2);
var orderElements = set.OrderBy(_ => _).ToArray();
orderElements[0].ShouldBe(0);
orderElements[1].ShouldBe(1);
}
public void ElementsAddedAndRemovedToListAreAddedToStateMap()
{
var set = new CSet <int> {
0, 1
};
AttachAndPersist(set);
set.Remove(0);
set.Remove(1);
Persist();
set = Load <CSet <int> >();
set.Count.ShouldBe(0);
}
public CSet Union(CSet aSet)
{
CSet tempSet = new CSet();
foreach (Object hashObject in data.Keys)
{
tempSet.Add(this.data[hashObject]);
}
foreach (Object hashObject in aSet.data.Keys)
{
if (!(this.data.ContainsKey(hashObject)))
{
tempSet.Add(aSet.data[hashObject]);
}
}
return(tempSet);
}
public bool isSubset(CSet aSet)
{
if (this.Size() > aSet.Size())
{
return(false);
}
else
{
foreach (Object key in this.data.Keys)
{
if (!(aSet.data.Contains(key)))
{
return(false);
}
}
return(true);
}
}
static void Main()
{
CSet setA = new CSet();
CSet setB = new CSet();
setA.Add("milk");
setA.Add("eggs");
setA.Add("bacon");
setA.Add("cereal");
setB.Add("bacon");
setB.Add("eggs");
setB.Add("bread");
CSet setC = new CSet();
setC = setA.Union(setB);
Console.WriteLine();
Console.WriteLine("A: " + setA.ToString());
Console.WriteLine("B: " + setB.ToString());
Console.WriteLine("A union B: " + setC.ToString());
setC = setA.Intersection(setB);
Console.WriteLine("A intersect B: " + setC.ToString());
setC = setA.Difference(setB);
Console.WriteLine("A diff B: " + setC.ToString());
setC = setB.Difference(setA);
Console.WriteLine("B diff A: " + setC.ToString());
if (setB.isSubset(setA))
{
Console.WriteLine("b is a subset of a");
}
else
{
Console.WriteLine("b is not a subset of a");
}
Console.ReadKey();
}
static void Main()
{
CSet setA = new CSet();
CSet setB = new CSet();
setA.Add(1);
setA.Add(2);
setA.Add(3);
setB.Add(2);
setB.Add(3);
CSet setC = new CSet();
setC = setA.Union(setB);
Console.WriteLine();
Console.WriteLine(setA.ToString());
Console.WriteLine(setC.ToString());
setC = setA.Intersection(setB);
Console.WriteLine(setC.ToString());
setC = setA.Difference(setB);
Console.WriteLine(setC.ToString());
bool flag = setB.isSubset(setA);
if (flag)
{
Console.WriteLine("b is a subset of a");
}
else
{
Console.WriteLine("b is not a subset of a");
}
Console.ReadKey();
}
//---------------------------------------------------------------------------------------------------------------------------------------------
public static void GetInfo(ref CSet cSet)
{
CSet_ = cSet;
Console.WriteLine($"Множество: {CSet_.Title}, количество элементов множества: {CSet_.quantity}; Всего создано объектов: {Count}");
}
//---------------------------------------------------------------------------------------------------------------------------------------------
static void Main(string[] args)
{
const int average = 6;
CSet setA = new CSet();
CSet setB = new CSet();
for (int i = 0; i <= average; i++)
{
setA.Add(i);
}
for (int i = 5; i <= 10; i++)
{
setB.Add(i);
}
CSet.GetInfo(ref setA);
Console.WriteLine(setA.ToString());
Console.WriteLine();
int c;
CSet.GetCount(out c);
Console.WriteLine($"Всего создано объектов: {c}");
Console.WriteLine(setA.ToStringEven());
Console.WriteLine(setA.ToStringUneven());
Console.WriteLine(setA.ToStringNegative());
Console.WriteLine();
CSet.GetInfo(ref setB);
Console.WriteLine(setB.ToString());
CSet setC = setA.Union(setB);
Console.WriteLine();
Console.WriteLine("множество A объединённо с множеством B: " + setC.ToString());
setC = setA.Intersection(setB);
Console.WriteLine("пересечение множества A с множеством B: " + setC.ToString());
setC = setA.Difference(setB);
Console.WriteLine("симметрическая разница множества A с множеством B: " + setC.ToString());
setC = setB.Difference(setA);
Console.WriteLine("симметрическая разница множества B с множеством A: " + setC.ToString());
if (setB.isSubset(setA))
{
Console.WriteLine("множество B является подмножеством множества A !");
}
else
{
Console.WriteLine("множество B не является подмножеством множества A !");
}
Console.WriteLine(new string('-', 20));
Console.WriteLine("Сравнение двух множеств...");
if (setA.Equals(setB))
{
Console.WriteLine("Множество A равносильно множеству B");
}
else
{
Console.WriteLine("Множество A не равносильно множеству B");
}
Console.WriteLine($"\nХэш множества A: {setA.GetHashCode()} \nХэш множества B: {setB.GetHashCode()}");
// Проверка, является ли переменная setA типа CSet
Console.WriteLine("\nПроверка, является ли переменная setA типа CSet...");
if (setA is CSet)
{
Console.WriteLine("Переменная setA имеет тип CSet");
}
else
{
Console.WriteLine("Переменная setA не имеет тип CSet");
}
Console.WriteLine(new string('-', 20));
var SET = new CSet("SET", 7);
CSet.GetInfo(ref SET);
Console.ReadKey();
}
public DistinctByOperator(Func <T, TDistinctBy> selector, CSet <TDistinctBy> set = null)
{
_selector = selector;
_set = set ?? new CSet <TDistinctBy>();
}
