public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
{
//a(a+b+c+d)/((a+b)(a+c))- 1
return
(float)(
quantifierSetting.secondContingencyTableRows[0][0] *
(
quantifierSetting.secondContingencyTableRows[0][0] +
quantifierSetting.secondContingencyTableRows[0][1] +
quantifierSetting.secondContingencyTableRows[1][0] +
quantifierSetting.secondContingencyTableRows[1][1]
)
)
/
(float)((
(
quantifierSetting.secondContingencyTableRows[0][0] +
quantifierSetting.secondContingencyTableRows[0][1]
)
*
(
quantifierSetting.secondContingencyTableRows[0][0] +
quantifierSetting.secondContingencyTableRows[1][0]
)
) - 1);
}
public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
{
//Differences between EConfidence (a+d)/(a+b+c+d)
return
((float)(
quantifierSetting.firstContingencyTableRows[0][0] +
quantifierSetting.firstContingencyTableRows[1][1]
)
/
(float)(
quantifierSetting.firstContingencyTableRows[0][0] +
quantifierSetting.firstContingencyTableRows[0][1] +
quantifierSetting.firstContingencyTableRows[1][0] +
quantifierSetting.firstContingencyTableRows[1][1]
))
-
((float)(
quantifierSetting.secondContingencyTableRows[0][0] +
quantifierSetting.secondContingencyTableRows[1][1]
)
/
(float)(
quantifierSetting.secondContingencyTableRows[0][0] +
quantifierSetting.secondContingencyTableRows[0][1] +
quantifierSetting.secondContingencyTableRows[1][0] +
quantifierSetting.secondContingencyTableRows[1][1]
))
;
}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="ownerOfAddIn">Owner of addin</param>
public AttributeFrequencyIce(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
{
this.ownerOfAddIn = ownerOfAddIn;
resManager = new ResourceManager("Ferda.FrontEnd.AddIns.AttributeFr.Localization_en-US",
Assembly.GetExecutingAssembly());
localizationString = "en-US";
}
/// <summary>
/// Default constructor for the class
/// </summary>
/// <param name="ownerOfAddIn">OwnerofAddIn</param>
/// <param name="form">Parent form</param>
public ExceptionCatcher(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn,
WaitDialog parent)
{
this.projectManager = ownerOfAddIn.ProjectManager;
this.ownerOfAddIn = ownerOfAddIn;
this.parentDialog = parent;
}
public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
{
//a+b
return
quantifierSetting.firstContingencyTableRows[0][0] +
quantifierSetting.firstContingencyTableRows[0][1];
}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="localePrefs">localeprefs</param>
/// <param name="tprx">Proxy</param>
/// <param name="ownerOfAddIn">Owner of addin</param>
public WaitDialog(string[] localePrefs, AbstractLMTaskFunctionsPrx tprx, Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
{
//setting the ResManager resource manager and localization string
string locale;
try
{
locale = localePrefs[0];
localizationString = locale;
locale = "Ferda.FrontEnd.AddIns.WaitDialog.Localization_" + locale;
resManager = new ResourceManager(locale, Assembly.GetExecutingAssembly());
}
catch
{
resManager = new ResourceManager("Ferda.FrontEnd.AddIns.WaitDialog.Localization_en-US",
Assembly.GetExecutingAssembly());
localizationString = "en-US";
}
this.KeyDown += new KeyEventHandler(WaitDialog_KeyDown);
this.tprx = tprx;
this.ownerOfAddIn = ownerOfAddIn;
InitializeComponent();
this.ChangeLocale(this.resManager);
ExceptionCatcher catcher = new ExceptionCatcher(this.ownerOfAddIn, this);
this.tprx.runAction_async(catcher);
}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="ownerOfAddIn">Owner of addin</param>
public ExplainTableIce(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
{
this.ownerOfAddIn = ownerOfAddIn;
//setting the ResManager resource manager and localization string
resManager = new ResourceManager("Ferda.FrontEnd.AddIns.ExplainTable.Localization_en-US",
Assembly.GetExecutingAssembly());
localizationString = "en-US";
}
/// <summary>
/// Default constructor of the class
/// </summary>
/// <param name="mod">Modules manager of the application</param>
/// <param name="resManager">Resource manager</param>
/// <param name="box">Box that has thrown the exception</param>
/// <param name="userMessage">Message to be displayed to the user</param>
public BoxExceptionClass(IBoxModule box, string userMessage, Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
{
// this.resourceManager = resManager;
this.box = box;
this.userMessage = userMessage;
this.modulesManager = ownerOfAddIn.ProjectManager.ModulesManager;
this.ownerOfAddIn = ownerOfAddIn;
}
public ResultBrowserIce(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn, Ferda.FrontEnd.Properties.IOtherObjectDisplayer Displayer)
{
this.ownerOfAddIn = ownerOfAddIn;
//setting the ResManager resource manager and localization string
resManager = new ResourceManager("Ferda.FrontEnd.AddIns.ResultBrowser.Localization_en-US",
Assembly.GetExecutingAssembly());
localizationString = "en-US";
this.Displayer = Displayer;
}
public void AddFactory(Ferda.Modules.BoxModuleFactoryPrx factoryPrx)
{
lock(this)
{
_factories[factoryPrx]=
Ferda.Modules.BoxModuleFactoryPrxHelper.uncheckedCast(
factoryPrx.ice_batchOneway()
);
}
}
public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
{
//a/(a+b)
return
(float)quantifierSetting.secondContingencyTableRows[0][0] /
(float)(
quantifierSetting.secondContingencyTableRows[0][0] +
quantifierSetting.secondContingencyTableRows[0][1]
);
}
public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
{
//(a+d)/(a+b+c+d)
return
(float)(
quantifierSetting.firstContingencyTableRows[0][0] +
quantifierSetting.firstContingencyTableRows[1][1]
)
/
(float)(
quantifierSetting.firstContingencyTableRows[0][0] +
quantifierSetting.firstContingencyTableRows[0][1] +
quantifierSetting.firstContingencyTableRows[1][0] +
quantifierSetting.firstContingencyTableRows[1][1]
);
}
public BoxModule(Ferda.Modules.BoxModulePrx iceBoxModulePrx, BoxModuleFactoryCreator madeInCreator, Helper helper, ModulesManager modulesManager)
{
this.iceBoxModulePrx = iceBoxModulePrx;
this.madeInCreator = madeInCreator;
this.iceIdentity = Ice.Util.identityToString(
iceBoxModulePrx.ice_getIdentity());
this.helper = helper;
this.modulesManager = modulesManager;
this.managersLocatorI = this.helper.ManagersEngineI.ManagersLocatorI;
foreach(PropertyInfo property in madeInCreator.Properties)
{
this.propertyNames.Add(property.name);
}
//string[] driver = this.MadeInCreator.PropertyDrivingLabel;
//if (driver != null && driver.Length != 0)
//{
// propertyDrivingLabel = driver[0];
//}
}
public abstract void GetProperty_async(Ferda.Modules.AMI_BoxModule_getProperty callBack, string name);
public StringSeqSettingModule(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
{
this.ownerOfAddIn = ownerOfAddIn;
}
/// <summary>
/// Ice run
/// </summary>
/// <param name="boxModuleParam">BoxModuleParams</param>
/// <param name="localePrefs">localeprefs</param>
/// <param name="manager">Manager proxy</param>
/// <param name="__current">Ice context</param>
public override void run(Ferda.Modules.BoxModulePrx boxModuleParam, string[] localePrefs, ManagersEnginePrx manager, Ice.Current __current)
{
string locale;
try
{
locale = localePrefs[0];
localizationString = locale;
locale = "Ferda.FrontEnd.AddIns.ExplainTable.Localization_" + locale;
resManager = new ResourceManager(locale, Assembly.GetExecutingAssembly());
}
catch
{
}
Ferda.Modules.Boxes.DataMiningCommon.DataMatrix.DataMatrixFunctionsPrx prx =
Ferda.Modules.Boxes.DataMiningCommon.DataMatrix.DataMatrixFunctionsPrxHelper.checkedCast(boxModuleParam.getFunctions());
try
{
string label = manager.getProjectInformation().getUserLabel(Ice.Util.identityToString(boxModuleParam.ice_getIdentity()));
Ferda.FrontEnd.AddIns.ExplainTable.ExplainTable control = new ExplainTable(localePrefs, prx.explain(), prx.getDataMatrixInfo(), ownerOfAddIn);
this.ownerOfAddIn.ShowDockableControl(control, resManager.GetString("Explain") + " " + label);
}
catch (Ferda.Modules.NoConnectionInSocketError)
{
MessageBox.Show(resManager.GetString("BoxNotConnected"), resManager.GetString("Error"),
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
catch (Ferda.Modules.BadParamsError ex)
{
if (ex.restrictionType == Ferda.Modules.restrictionTypeEnum.DbConnectionString)
{
MessageBox.Show(resManager.GetString("BadConnectionString"), resManager.GetString("Error"),
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else if (ex.restrictionType == Ferda.Modules.restrictionTypeEnum.DbTable)
{
MessageBox.Show(resManager.GetString("NoDataMatrix"), resManager.GetString("Error"),
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
public abstract void SetConnection(string socketName, Ferda.ModulesManager.IBoxModule otherModule);
public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
{
return (float)Common.Functions.Max(quantifierSetting.firstContingencyTableRows);
}
/// <summary>
/// Helper method for registering standard box to Ice Object Adapter
/// </summary>
/// <param name="identity">Name of box</param>
/// <param name="boxInfo">An <see cref="T:Ferda.Modules.Boxes.IBoxInfo"/> implementation for this box</param>
public void registerBox(string identity, Ferda.Modules.Boxes.IBoxInfo boxInfo)
{
Debug.WriteLine("Registering " + identity + "...");
BoxModuleFactoryCreatorI boxModuleFactoryCreator = new BoxModuleFactoryCreatorI(boxInfo, reaper);
Ice.ObjectPrx newPrx = _adapter.add(boxModuleFactoryCreator, Ice.Util.stringToIdentity(identity));
}
void Ferda.Modules.IFunctions.setBoxModuleInfo(Ferda.Modules.BoxModuleI boxModule, Ferda.Modules.Boxes.IBoxInfo boxInfo)
{
this.boxModule = boxModule;
this.boxInfo = boxInfo;
}
public override void RemoveConnection(string socketName, Ferda.ModulesManager.IBoxModule otherModule)
{
this.RemoveUnvisibleConnection(socketName, otherModule);
List<Ferda.ModulesManager.IBoxModule> modulesInSocket;
if(connectedModules.TryGetValue(socketName, out modulesInSocket))
{
modulesInSocket.Remove(otherModule);
}
BoxModuleForManager otherModuleForManager = otherModule
as BoxModuleForManager;
otherModuleForManager.RemoveConnectionTo(this);
}
/// <summary>
/// Run method
/// </summary>
/// <param name="boxModuleParam"></param>
/// <param name="localePrefs">Locale prefs</param>
/// <param name="manager">Manager proxy</param>
/// <param name="__current">Ice context</param>
public override void run(Ferda.Modules.BoxModulePrx boxModuleParam, string[] localePrefs, ManagersEnginePrx manager, Ice.Current __current)
{
string locale;
try
{
locale = localePrefs[0];
localizationString = locale;
locale = "Ferda.FrontEnd.AddIns.ColumnFr.Localization_" + locale;
resManager = new ResourceManager(locale, Assembly.GetExecutingAssembly());
}
catch
{
}
Ferda.Modules.Boxes.DataMiningCommon.Column.ColumnFunctionsPrx prx =
Ferda.Modules.Boxes.DataMiningCommon.Column.ColumnFunctionsPrxHelper.checkedCast(boxModuleParam.getFunctions());
Ferda.Modules.Boxes.DataMiningCommon.Attributes.Attribute.AttributeFunctionsPrx prx1 =
Ferda.Modules.Boxes.DataMiningCommon.Attributes.Attribute.AttributeFunctionsPrxHelper.checkedCast(boxModuleParam.getFunctions());
try
{
ColumnInfo columnInfo = prx.getColumnInfo();
string label = manager.getProjectInformation().getUserLabel(Ice.Util.identityToString(boxModuleParam.ice_getIdentity()));
Ferda.FrontEnd.AddIns.ColumnFrequency.ColumnFrequency control = new ColumnFrequency(localePrefs, columnInfo, ownerOfAddIn);
this.ownerOfAddIn.ShowDockableControl(control, label + " " + resManager.GetString("ColumnFrequency"));
}
catch (Ferda.Modules.BadParamsError ex)
{
if (ex.restrictionType == Ferda.Modules.restrictionTypeEnum.DbConnectionString)
{
MessageBox.Show(resManager.GetString("BadConnectionString"), resManager.GetString("Error"),
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else if (ex.restrictionType == Ferda.Modules.restrictionTypeEnum.DbTable)
{
MessageBox.Show(resManager.GetString("NoDataMatrix"), resManager.GetString("Error"),
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else if (ex.restrictionType == Ferda.Modules.restrictionTypeEnum.DbColumn)
{
MessageBox.Show(resManager.GetString("BadColumnSelectExpression"), resManager.GetString("Error"),
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
//else
{
MessageBox.Show(resManager.GetString("InvalidParameters"), resManager.GetString("Error"),
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
catch (Ferda.Modules.NoConnectionInSocketError)
{
MessageBox.Show(resManager.GetString("BoxNotConnected"), resManager.GetString("Error"),
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
/// <summary>
/// Load the addins to the FrontEnd
/// </summary>
/// <param name="ownerOfAddIn">Who will own this addin</param>
/// <param name="objectAdapter">Some ice stuff</param>
/// <param name="modulesManager">Modules Manager</param>
/// <param name="displayer">Displayer of the properties (if an Add-in has a property)</param>
private static void loadAddIns(IOwnerOfAddIn ownerOfAddIn,
Ice.ObjectAdapter objectAdapter,
Ferda.ModulesManager.ModulesManager modulesManager, Properties.IOtherObjectDisplayer displayer)
{
System.Collections.Specialized.StringCollection proxies
= new System.Collections.Specialized.StringCollection();
foreach(string file in System.IO.Directory.GetFiles("AddIns"))
{
if(System.IO.Path.GetExtension(file) == ".dll")
{
string path = "Ferda.FrontEnd.AddIns." +
System.IO.Path.GetFileNameWithoutExtension(file) +
".Main";
//tohle se nezvladne
Assembly asembly =
System.Reflection.Assembly.LoadFile(System.IO.Path.GetFullPath(file));
IAddInMain addInMain = (IAddInMain)asembly.CreateInstance(path);
//adding the properties displayer if it is a addin capable of
//displaying properties
if (addInMain is Properties.IPropertyProvider)
{
Properties.IPropertyProvider prov = addInMain as
Properties.IPropertyProvider;
prov.Displayer = displayer;
}
addInMain.OwnerOfAddIn = ownerOfAddIn;
addInMain.ObjectAdapter = objectAdapter;
proxies.AddRange(addInMain.ObjectProxiesToAdd);
addIns.Add(addInMain);
}
}
int count = proxies.Count;
string[] newServices = new string[count];
if(count > 0)
{
proxies.CopyTo(newServices, 0);
}
modulesManager.AddModuleServices(newServices);
}
public override string GetPropertyOtherAboutFromValue(string name, Ferda.Modules.PropertyValue value)
{
SettingModulePrx prx = this.managersLocatorI.findSettingModule(
this.madeInCreator.GetProperty(name).settingModuleIdentifier);
if (prx != null)
return prx.getPropertyAbout(value);
else
return "";
}
public override void SetPropertyOther(string name, Ferda.Modules.PropertyValue value)
{
this.iceBoxModulePrx.setProperty(name,value);
}
public abstract void SetPropertyOther(string name, Ferda.Modules.PropertyValue value);
public abstract string GetPropertyOtherAboutFromValue(string name, Ferda.Modules.PropertyValue value);
/// <summary>
/// Generates the the attribute.
/// </summary>
/// <param name="domainType">Type of the domain.</param>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
/// <param name="countOfCategories">The count of categories.</param>
/// <param name="columnInfo">The column info.</param>
/// <param name="boxIdentity">The box identity.</param>
/// <returns>Generated attribute.</returns>
public static GeneratedAttribute Generate(
AttributeDomainEnum domainType,
double from,
double to,
long countOfCategories,
Ferda.Modules.Boxes.DataMiningCommon.Column.ColumnInfo columnInfo,
string boxIdentity)
{
Ferda.Modules.Helpers.Data.Column.ValueType simpleColumnType = Ferda.Modules.Helpers.Data.Column.GetColumnValueTypeByValueSubType(columnInfo.columnSubType);
if (simpleColumnType != Ferda.Modules.Helpers.Data.Column.ValueType.Integral
&& simpleColumnType != Ferda.Modules.Helpers.Data.Column.ValueType.Floating)
throw Ferda.Modules.Exceptions.BadParamsError(null, boxIdentity, simpleColumnType.ToString(), restrictionTypeEnum.DbColumnDataType);
//dataArray.Add(new Data(currentValue, currentCount));
ArrayList dataArray = new ArrayList();
DataTable frequencies = null;
float startValue = Convert.ToSingle(columnInfo.statistics.ValueMin);
float endValue = Convert.ToSingle(columnInfo.statistics.ValueMax);
switch (domainType)
{
case AttributeDomainEnum.WholeDomain:
frequencies = Ferda.Modules.Helpers.Data.Column.GetDistinctsAndFrequencies(
columnInfo.dataMatrix.database.odbcConnectionString,
columnInfo.dataMatrix.dataMatrixName,
columnInfo.columnSelectExpression,
boxIdentity);
from = to = 0;
break;
case AttributeDomainEnum.SubDomainValueBounds:
frequencies = Ferda.Modules.Helpers.Data.Column.GetDistinctsAndFrequencies(
columnInfo.dataMatrix.database.odbcConnectionString,
columnInfo.dataMatrix.dataMatrixName,
columnInfo.columnSelectExpression,
columnInfo.columnSelectExpression + ">=" + from + " AND " + columnInfo.columnSelectExpression + "<=" + to,
boxIdentity);
startValue = (float)from;
endValue = (float)to;
from = to = 0;
break;
case AttributeDomainEnum.SubDomainNumberOfValuesBounds:
frequencies = Ferda.Modules.Helpers.Data.Column.GetDistinctsAndFrequencies(
columnInfo.dataMatrix.database.odbcConnectionString,
columnInfo.dataMatrix.dataMatrixName,
columnInfo.columnSelectExpression,
boxIdentity);
break;
default:
throw Ferda.Modules.Exceptions.SwitchCaseNotImplementedError(domainType);
}
if (from < 0)
{
throw Ferda.Modules.Exceptions.BadValueError(null, boxIdentity, null, new string[] { "From" }, restrictionTypeEnum.Minimum);
}
if (to < 0)
{
throw Ferda.Modules.Exceptions.BadValueError(null, boxIdentity, null, new string[] { "To" }, restrictionTypeEnum.Minimum);
}
int fromUi = (int)from;
int toUi = (int)to;
int frequenciesCount = frequencies.Rows.Count;
if (frequenciesCount <= from + to)
return new GeneratedAttribute();
object item;
switch (simpleColumnType)
{
case Ferda.Modules.Helpers.Data.Column.ValueType.Floating:
for (int i = fromUi; i < (frequenciesCount - toUi); i++)
{
item = frequencies.Rows[i][Ferda.Modules.Helpers.Data.Column.SelectDistincts];
if (item == System.DBNull.Value)
continue;
dataArray.Add(new EquifrequencyIntervalGenerator.Data(Convert.ToSingle(item), Convert.ToInt32(frequencies.Rows[i][Ferda.Modules.Helpers.Data.Column.SelectFrequency])));
}
break;
case Ferda.Modules.Helpers.Data.Column.ValueType.Integral:
for (int i = fromUi; i < (frequenciesCount - toUi); i++)
{
item = frequencies.Rows[i][Ferda.Modules.Helpers.Data.Column.SelectDistincts];
if (item == System.DBNull.Value)
continue;
dataArray.Add(new EquifrequencyIntervalGenerator.Data(Convert.ToInt64(item), Convert.ToInt32(frequencies.Rows[i][Ferda.Modules.Helpers.Data.Column.SelectFrequency])));
}
break;
default:
throw Ferda.Modules.Exceptions.BadParamsError(null, boxIdentity, simpleColumnType.ToString(), restrictionTypeEnum.DbColumnDataType);
}
object[] splitPoints = null;
try
{
splitPoints = EquifrequencyIntervalGenerator.GenerateIntervals((int)countOfCategories, dataArray);
}
catch (ArgumentOutOfRangeException ex)
{
if (ex.ParamName == "intervals")
{
throw Ferda.Modules.Exceptions.BadValueError(ex, boxIdentity, null, new string[] { "CountOfCategories" }, restrictionTypeEnum.Other);
}
else
throw ex;
}
if (splitPoints == null)
return new GeneratedAttribute();
CategoriesStruct categoriesStruct = new CategoriesStruct();
string categoryName;
List<SelectString> categoriesNames = new List<SelectString>();
SelectString categoriesNamesItem;
bool computeCategoriesNames = (splitPoints.Length + 1 < Ferda.Modules.Boxes.DataMiningCommon.Attributes.AbstractAttributeConstants.MaxLengthOfCategoriesNamesSelectStringArray);
switch (simpleColumnType)
{
case Ferda.Modules.Helpers.Data.Column.ValueType.Floating:
categoriesStruct.floatIntervals = new FloatIntervalCategorySeq();
float beginValueFl = startValue;
float nextValueFl;
FloatIntervalStruct intervalFlTemplate = new FloatIntervalStruct();
intervalFlTemplate.leftBoundType = BoundaryEnum.Sharp;
intervalFlTemplate.rightBoundType = BoundaryEnum.Round;
FloatIntervalStruct intervalFl;
for (int i = 0; i < splitPoints.Length + 1; i++)
{
if (i == splitPoints.Length)
{
nextValueFl = endValue;
intervalFlTemplate.rightBoundType = BoundaryEnum.Sharp;
}
else
nextValueFl = (float)splitPoints[i];
intervalFl = intervalFlTemplate;
intervalFl.leftBound = beginValueFl;
intervalFl.rightBound = nextValueFl;
categoryName = Constants.LeftClosedInterval + beginValueFl.ToString() + Constants.SeparatorInterval + nextValueFl.ToString();
categoryName += (intervalFl.rightBoundType == BoundaryEnum.Sharp)? Constants.RightClosedInterval : Constants.RightOpenedInterval;
if (computeCategoriesNames)
{
categoriesNamesItem = new SelectString();
categoriesNamesItem.name = categoryName;
categoriesNamesItem.label = categoryName;
categoriesNames.Add(categoriesNamesItem);
}
categoriesStruct.floatIntervals.Add(
categoryName,
new FloatIntervalStruct[] { intervalFl });
beginValueFl = nextValueFl;
}
return new GeneratedAttribute(
categoriesStruct,
null,
categoriesStruct.floatIntervals.Count,
categoriesNames.ToArray());
case Ferda.Modules.Helpers.Data.Column.ValueType.Integral:
categoriesStruct.longIntervals = new LongIntervalCategorySeq();
long beginValueLn = (long)startValue;
long nextValueLn;
LongIntervalStruct intervalLnTemplate = new LongIntervalStruct();
intervalLnTemplate.leftBoundType = BoundaryEnum.Sharp;
intervalLnTemplate.rightBoundType = BoundaryEnum.Round;
LongIntervalStruct intervalLn;
for (int i = 0; i < splitPoints.Length + 1; i++)
{
if (i == splitPoints.Length)
{
nextValueLn = (long)endValue;
intervalLnTemplate.rightBoundType = BoundaryEnum.Sharp;
}
else
nextValueLn = (long)splitPoints[i];
intervalLn = intervalLnTemplate;
intervalLn.leftBound = beginValueLn;
intervalLn.rightBound = nextValueLn;
categoryName = Constants.LeftClosedInterval + beginValueLn.ToString() + Constants.SeparatorInterval + nextValueLn.ToString();
categoryName += (intervalLn.rightBoundType == BoundaryEnum.Sharp)? Constants.RightClosedInterval : Constants.RightOpenedInterval;
if (computeCategoriesNames)
{
categoriesNamesItem = new SelectString();
categoriesNamesItem.name = categoryName;
categoriesNamesItem.label = categoryName;
categoriesNames.Add(categoriesNamesItem);
}
categoriesStruct.longIntervals.Add(
categoryName,
new LongIntervalStruct[] { intervalLn });
beginValueLn = nextValueLn;
}
return new GeneratedAttribute(
categoriesStruct,
null,
categoriesStruct.longIntervals.Count,
categoriesNames.ToArray());
default:
throw Ferda.Modules.Exceptions.BadParamsError(null, boxIdentity, simpleColumnType.ToString(), restrictionTypeEnum.DbColumnDataType);
}
}
public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
{
return float.NaN;
}
public override void SetConnection(string socketName, Ferda.ModulesManager.IBoxModule otherModule)
{
this.SetUnvisibleConnection(socketName, otherModule);
List<Ferda.ModulesManager.IBoxModule> modulesInSocket;
if(!connectedModules.TryGetValue(socketName,out modulesInSocket))
{
modulesInSocket = new List<Ferda.ModulesManager.IBoxModule>();
connectedModules[socketName] = modulesInSocket;
}
if(!modulesInSocket.Contains(otherModule))
{
modulesInSocket.Add(otherModule);
BoxModuleForManager otherModuleForManager = otherModule
as BoxModuleForManager;
otherModuleForManager.AddConnectionTo(this);
}
}
