private void initGr(string v)
{
elmGroups.Clear();
gr.Prf = v;
gr.prf = Lib.ToLat(v.ToLower());
elmGroups.Add(gr);
}
public Section(string _text, SType stype = SType.NOT_DEFINED)
{
if (SectionTab == null)
{
SectionTab = new Boot.initSection().SectionTab;
}
string[] sections = Lib.ToLat(_text).ToLower().Replace(" ", "").Split(';');
if (stype == SType.NOT_DEFINED)
{
type = SecType(sections[0]);
body = SecBody(sections[0]);
refSection = SecRef(sections[0]);
return;
}
foreach (string str in sections)
{
if (SecType(str) != stype)
{
continue;
}
type = stype;
body = SecBody(str);
return;
}
type = SType.NOT_DEFINED;
body = string.Empty;
}
protected SType SecType(string text)
{
if (string.IsNullOrEmpty(text) || !text.Contains(':'))
{
return(SType.NOT_DEFINED);
}
string hdr = text.Substring(0, text.IndexOf(':'));
hdr = Lib.ToLat(hdr).ToLower().Replace(" ", "");
foreach (SType sec in Enum.GetValues(typeof(SType)))
{
if (sec == SType.NOT_DEFINED)
{
continue;
}
List <string> synonyms = SectionTab[sec.ToString()].ToList();
var secFound = synonyms.Find(x =>
x.Length > hdr.Length? false:
x == hdr.Substring(0, x.Length));
if (secFound != null)
{
return(sec);
}
}
return(SType.NOT_DEFINED);
}
/// <summary>
/// Имитация группировки из ElmAttSet.Group
/// </summary>
/// <param name="i">номер группы</param>
internal ElmAttSet.Group IM_Group(string mat = "", string prf = "")
{
var model = IM_Model();
var elements = IM_Elements();
mat = Lib.ToLat(mat).ToLower().Replace(" ", "");
prf = Lib.ToLat(prf).ToLower().Replace(" ", "");
ElmAttSet.Group result = null;
model.setElements(elements.Values.ToList());
model.getGroups();
foreach (var gr in model.elmGroups)
{
if (mat != "" && gr.mat != mat)
{
continue;
}
if (prf != "" && gr.prf != prf)
{
continue;
}
result = gr;
}
if (result == null)
{
Assert.Fail();
}
return(result);
}
public Parameter(string str)
{
str = Lib.ToLat(str).ToLower().Replace(" ", "");
if(string.IsNullOrWhiteSpace(str))
{
ptype = ParType.ANY;
tx = string.Empty;
par = str;
return;
}
int indx = str.IndexOf(':') + 1;
Regex parametr = new Regex(@"\{.+?\}");
Match m = parametr.Match(str, indx);
ptype = getParType(str);
if (m.Value.Length > 0)
{ // string like "{result}" with the Brackets
par = Regex.Replace(m.Value, @"\{.*?~|\{|\}", "");
tx = str.Substring(indx, m.Index - indx);
}
else
{ // result is part of str, recognised as a parameter value
int end = str.IndexOf(';');
if (end < indx) end = str.Length;
tx = str.Substring(indx, end - indx);
par = tx;
}
}
// for internal use, f.e. for comparision
public string viewComp_(SType stype)
{
string str = "";
try { str = compDP.dpar[stype]; }
catch { str = "##NOT_AVAILABLE##"; }
return(Lib.ToLat(str.ToLower()));
}
private static void sub(SType t, params string[] str)
{
List <string> lst = new List <string>();
foreach (string s in str)
{
lst.Add(Lib.ToLat(s).ToLower().Replace(" ", "").Replace(".", "").Replace("/", ""));
}
SectionTab.Add(t.ToString(), lst);
}
private void initGr(string v, string mat = "C245")
{
inp.Clear();
gr.Prf = v;
gr.prf = Lib.ToLat(v.ToLower().Replace(" ", ""));
gr.Mat = mat;
gr.mat = Lib.ToLat(mat.ToLower().Replace(" ", ""));
inp.Add(gr);
//23/7 mod.elmGroups = inp;
}
public void UT_Component_checkComp_L()
{
//test 1: gr="L75x5" rule="Профиль: Уголок=L *x*;" => TRUE
gr.prf = "l75x5";
rule.text = Lib.ToLat("Профиль: Уголок=L *x*;");
rule.ruleDP = new DPar.DPar(rule.text);
rule.synonyms = rule.RuleSynParse(rule.text.ToLower());
comp.compDP = new DPar.DPar("Prf:Уголок 75 x 5");
string vs = rule.synonyms[Section.Section.SType.Profile][0];
string vd = comp.viewComp_(Section.Section.SType.Profile);
Assert.IsTrue(vd.Contains(vs));
Assert.AreEqual(comp.compDP.dpar.Count, 1);
var v = comp.compDP.dpar[Section.Section.SType.Profile];
Assert.AreEqual(v, "угoлoк75x5");
bool b = comp.isMatch(gr, rule);
Assert.IsTrue(b);
//test 4: gr="I20" rule="Профиль: Балка =I* дл;" comp="Балка 20 дл. 9м Ст3пс5" => TRUE
gr.Prf = "I20"; gr.prf = "i20";
rule.text = "Профиль: Балка =I*";
string comp_txt = "Балка 20"; // <==!!
rule.ruleDP = new DPar.DPar(rule.text);
rule.synonyms = rule.RuleSynParse(rule.text);
var syns = rule.synonyms[Section.Section.SType.Profile].ToList();
Assert.AreEqual(syns[0], "бaлкa");
Assert.AreEqual(syns[1], "i");
comp.compDP = new DPar.DPar("Prf:" + comp_txt);
Assert.AreEqual(comp.compDP.dpar.Count, 1);
Assert.AreEqual(comp.compDP.dpStr[Section.Section.SType.Profile], comp_txt);
b = comp.isMatch(gr, rule);
Assert.IsTrue(b);
//test 4-1: gr="I30Ш2" rule="Профиль: Двутавр=I*Ш*" => TRUE
initGr("I30Ш2");
initRule("М: C245=C255 ; Профиль: Двутавр=I*Ш*");
initComp("двутавр 30Ш2");
b = comp.isMatch(gr, rule);
Assert.IsTrue(b);
//test 5: gr="Гн.100x4" rule="Профиль: Швеллер = U*П_;" => TRUE
initGr("Гн.100x4");
initRule("Профиль: Гн.*х*");
initComp("Гн. 100х4");
b = comp.isMatch(gr, rule);
Assert.IsTrue(b);
//test 6: gr="Гн.100x4" rule="Профиль: Швеллер = U*П_;" Comp=M:C345 => FALSE
initGr("Гн.100x46");
initRule("Профиль: Уголок=L *x*x*");
initComp("Гн. 100х4", "C345");
b = comp.isMatch(gr, rule);
Assert.IsTrue(!b);
}
public Group(IGrouping <string, Elm> group)
{
elmsDic = group.ToDictionary(x => x.guid);
Mat = elmsDic.First().Value.mat;
Prf = elmsDic.First().Value.prf;
mat = Lib.ToLat(Mat.ToLower().Replace("*", "x"));
prf = Lib.ToLat(Prf.ToLower().Replace("*", "x"));
guids = group.Select(x => x.guid).ToList();
totalLength = group.Select(x => x.length).Sum();
totalWeight = group.Select(x => x.weight).Sum();
totalVolume = group.Select(x => x.volume).Sum();
}
public double RuleRedundencyPerCent = 0.0; //коэффициент избыточности, требуемый запас по данному материалу/профилю/Правилу
public Rule(Docs doc, int i)
{
name = (string)doc.Body[i, Decl.RULE_NAME];
type = (string)doc.Body[i, Decl.RULE_TYPE];
text = Lib.ToLat((string)doc.Body[i, Decl.RULE_RULE]);
synonyms = RuleSynParse(text);
ruleDP = new DP(text); // template for identification
string csName = (string)doc.Body[i, Decl.RULE_COMPSETNAME];
string suplName = (string)doc.Body[i, Decl.RULE_SUPPLIERNAME];
Supplier = new Suppliers.Supplier(suplName);
CompSet = new CmpSet(csName, Supplier);
}
private static void testFP_synonym(FingerPrint fp)
{
Log.set("testFP_synonym(fp)");
int iStart = 0;
string str = Lib.ToLat("L=Уголок*").ToLower();
TST.Eq(fp.isSynonym(str, iStart), true);
TST.Eq(fp.synParser(str, ref iStart), "l");
TST.Eq(iStart, 2);
string tx = str.Substring(iStart);
TST.Eq(tx, Lib.ToLat("Уголок*").ToLower());
Log.exit();
}
/// <summary>
/// PrfNormalize operate in <Full>, or in <Mark> mode:
/// <para> - Mark: only setup Mark (i.e. Profile type) as pointed in first argument, or</para>
/// <para> - Full: setup Mark, and sort digital parameter values the profile template list;</para>
/// </summary>
private void PrfNormalize(ref List<ElmGr> grp, params string[] prfMark)
{
foreach (var gr in grp)
{
foreach (string s in prfMark)
{
if (!gr.Prf.Contains(s) && !gr.prf.Contains(s)) continue;
string initialPrf = gr.Prf;
gr.Prf = PrfNormStr(gr.prf, prfMark[0], Lib.GetPars(gr.Prf));
gr.prf = Lib.ToLat(gr.Prf.ToLower());
log.Info("--- " + initialPrf + " -> " + "Prf=" + gr.Prf + "gr.prf=" + gr.prf);
break;
}
}
}
public List <Par> secPars(string template)
{
List <Par> result = new List <Par>();
template = Lib.ToLat(template).ToLower().Replace(" ", "");
template = SecBody(template);
string pattern = "^" + template.Replace("*", @"(.*?)") + "$";
Regex r = new Regex(pattern);
Match m = r.Match(body);
for (int i = 1; i < m.Groups.Count; i++)
{
result.Add(new Par(m.Groups[i].Value));
}
return(result);
}
/// <summary>
/// имитация списка синонимов - только для отладки
/// </summary>
/// <param name="i"></param>
internal void IM_setRuleSynonyms(ref Rule.Rule rule, int i = -1)
{
//24/3 if (i < 0) { rule.synonyms = null; return; }
var anglePrf = new List <string> {
"l", "Уголок равнопол."
};
var synonyms = new Dictionary <SType, List <string> >();
rule.synonyms = synonyms;
List <string> syns = new List <string>();
foreach (string syn in anglePrf)
{
syns.Add(Lib.ToLat(syn).ToLower().Replace(" ", ""));
}
rule.synonyms.Add(SType.Profile, syns);
}
public Rule(Docs doc, int i)
{
date = Lib.getDateTime(doc.Body.Strng(i, Decl.RULE_DATE));
Text = doc.Body.Strng(i, Decl.RULE_RULETEXT);
text = Lib.ToLat(Text.ToLower());
synonyms = RuleSynParse(text);
ruleDP = new DP(text);
sSupl = doc.Body.Strng(i, Decl.RULE_SUPPLIERNAME);
sCS = doc.Body.Strng(i, Decl.RULE_COMPSETNAME);
if (date > DateTime.Now || date < Decl.OLD ||
string.IsNullOrWhiteSpace(Text) ||
string.IsNullOrWhiteSpace(sSupl) ||
string.IsNullOrWhiteSpace(sCS))
{
throw new InvalidCastException("Rule line " + i);
}
}
public void UT_Parameter_Test()
{
var utp = new UT_Par("{4}");
Assert.AreEqual(utp.type, "String");
Assert.AreEqual(utp.tx, "");
Assert.AreEqual(utp.par.ToString(), "4");
utp = new UT_Par("Ab{123}cD");
Assert.AreEqual(utp.type, "String");
Assert.AreEqual((string)utp.par, "123");
Assert.AreEqual(utp.tx, "ab");
utp = new UT_Par("текст");
Assert.AreEqual(utp.type, "String");
Assert.AreEqual(utp.tx, Lib.ToLat("текст"));
Assert.AreEqual((string)utp.par, utp.tx);
utp = new UT_Par("x{3");
Assert.AreEqual((string)utp.par, "x{3");
Assert.AreEqual(utp.tx, (string)utp.par);
utp = new UT_Par("def}fg");
Assert.AreEqual((string)utp.par, "def}fg");
Assert.AreEqual(utp.tx, (string)utp.par);
utp = new UT_Par("Da{34{85}uy");
Assert.AreEqual(utp.tx, "da");
Assert.AreEqual((string)utp.par, "3485"); // поскольку внутреняя { стирается
///---- ParType test
utp = new UT_Par("цена: {d~3}");
Assert.AreEqual(utp.type, "Double");
Assert.AreEqual((string)utp.par, "3");
Assert.AreEqual(parType("{2}"), "String");
Assert.AreEqual(parType("{s~2}"), "String");
Assert.AreEqual(parType("{i~4}"), "Integer");
Assert.AreEqual(parType("{d~3}"), "Double");
Assert.AreEqual(parType("{digital~3}"), "Double");
Assert.AreEqual(parType("текст{i~1}b{d~2,2}ff"), "Integer");
Assert.AreEqual(parType("другой текст"), "String");
Assert.AreEqual(parType(""), "String");
// Assert.Fail();
}
internal ElmAttSet.Group IM_Group(string str)
{
var model = IM_Model();
var elements = IM_Elements();
model.setElements(elements.Values.ToList());
model.getGroups();
string text = Lib.ToLat(str).ToLower();
foreach (var gr in model.elmGroups)
{
if (gr.mat.Contains(text))
{
return(gr);
}
}
return(null);
}
public bool isSectionMatch(string template)
{
if (!SectionTab.Any())
{
Msg.F("SectionTab is empty");
}
string[] sections = Lib.ToLat(template).ToLower().Replace(" ", "").Split(';');
foreach (string str in sections)
{
if (SecType(str) != type)
{
continue;
}
string templ = SecBody(str).Replace("*", "(.*?)");
return(Regex.IsMatch(body, templ));
}
return(false);
}
public Group(Dictionary <string, ElmAttSet> Els, string _mat, string _prf, List <string> _guids)
{
Elements = Els;
mat = Lib.ToLat(_mat.ToLower());
prf = Lib.ToLat(_prf.ToLower());
guids = _guids;
totalLength = totalWeight = totalVolume = totalPrice = 0.0;
foreach (var id in guids)
{
if (Els[id].mat != mat)
{
continue;
}
totalLength += Els[id].length;
totalVolume += Els[id].volume;
totalWeight += Els[id].weight;
totalPrice += Els[id].price;
}
}
///<summary> /// private RuleParser(string) - Parse string text of Rule to fill Rule parameters.
/// Regular Expression methodisa are in use.
///</summary>
/// <описание>
/// -------------------------- СИНТАКСИС ПРАВИЛ -----------------------
/// RuleParser разбирает текстовую строку - правило, выделяя и возвращая в списках или полях,
/// входящих в состав класса Rule значения и списки, полученные из текста Правила.
/// ...... Части Правила, иначе - Разделы или Секции ......
/// Разделы начинаются признаком раздела, например, "Материал:" и разделяются между собой знаком ';'.
/// Заголовок раздела распознается по первым буквам 'M' (Материал), "Пр" ("Pr" для английского текста),
/// 'C' (Cost или Стоимость) или 'Ц' (Цена) и завершается ':'. Поэтому
/// "Профиль:" = "П:" = "Прф:" = "п:" = "Prof:"
/// Заглавные и строчные буквы эквивалентны, национальные символы переводятся в эквивалентные по начертанию
/// знаки латинского алфавита, чтобы избежать путаницы между латинским Х и русским Х.
/// Разделы Правила можно менять местами и пропускать; тогда они работают "по умолчанию".
/// В теле раздела могут быть синонимы - альтернативные обозначения Материала или Профиля. Их синтаксис:
/// '=' означает эквивалентность. Допустимы выражения "C255=Ст3=сталь3".
/// ',' позволяет перечислять элементы и подразделы Правила.
/// ' ' пробелы, табы и знаки конца строки игнорируются, однако они могут служить
/// признаком перечисления, так же, как пробелы. Таким образом, названия материалов
/// или профилей можно просто перечислить - это эквивалентно '='
/// В результате работы метода RuleParser списки альтернативных наименований для Материала, Профили и Прочего
/// RuleMatList - список допустимых альтернативных наименований материалов, с которыми работает Правило
/// RulePrfList - список альтернативных наименований Профиля
/// RuleCstList - список альтернативных наименований других разделов Правила
/// ...... Параметры ......
/// Текст Раздела Правила может иметь т.н. Параметры - символические обозначения каких-либо значений.
/// Например,"$p1" или просто "p1" или "Параметр235". Параметр начинается со знака'$' или 'p' и кончается цифрой,
/// причем знак '$' можно опускать. Значение Параметра подставляется из атрибутов модели в САПР в порядке следования
/// Параметров в Правиле.
///
/// #параметры - величины в Правиле, которые соответствуют "значению" в тексте атрибута или прайс-листа,
/// например, номер колонки с весом или с ценой
/// *параметры - Wild параметр комплектующих; соответствующий элемент модели может иметь
/// любое значение, например, ширина листа, из которого нарезают полосы
/// Redunduncy% параметр - коэффициент запаса в процентах. Перед десятичным числом -
/// коэффициентом запаса - могут быть ключевые слова, возможно, сокращенные
/// (избыток, запас, отходы, Redundency, Excess, Waste) по русски или
/// по английски заглавными или строчными буквами.
/// </описание>
/// <history> декабрь 2015 - январь 2016 предистория
/// 19.2.16 - #параметры
/// 29.2.16 - *параметры
/// 17.10.16 - перенос в Rule class
/// 28.12.16 - введены Параметры вида {..} правила. Остальные типы правил пока не разбираем
/// 25.03.17 - переписал с использованием Section
/// </history>
public Dictionary <SType, FP> Parser(FP.type _type, string text)
{
Log.set("Rule.Parser(" + _type + ", " + text);
Dictionary <SType, FP> result = new Dictionary <SType, FP>();
string[] sections = Lib.ToLat(text).ToLower().Split(';');
foreach (string sec in sections)
{
Sec txSec = new Sec(sec);
if (txSec.type == SType.NOT_DEFINED)
{
continue;
}
FP fp = new FP(_type, txSec.body);
result.Add(txSec.type, fp);
}
Log.exit();
return(result);
}
public ProfileUpdate(ref List<ElmGr> elmGroups)
{
if (PrfTab == null || PrfTab.Count == 0 || elmGroups == null || elmGroups.Count == 0)
Msg.F("internal errer");
foreach (var gr in elmGroups)
{
foreach (var Mark in PrfTab)
{
string[] marks = Mark.Value.Split('|');
foreach (string mark in marks)
{
if (gr.prf.Length < mark.Length || gr.prf.Substring(0, mark.Length) != mark) continue;
Profile = gr.Prf; profile = gr.prf;
gr.Prf = PrfNormStr(Mark.Key);
gr.prf = Lib.ToLat(gr.Prf.ToLower().Replace(" ", ""));
if (gr.Prf != Profile) goto NextGr;
} // end foreach '|' part
} // end PrfTab entry
NextGr:;
} // end elmGroup
}
public Section(string _text, SType stype = SType.NOT_DEFINED)
{
string[] sections = Lib.ToLat(_text).ToLower().Replace(" ", "").Split(';');
foreach (string str in sections)
{
type = SecType(str);
body = SecBody(str);
refSection = SecRef(str);
if (type == SType.Unit)
{
type = SecType((body + ":").Replace("/", "").Replace(".", ""));
body = string.Empty;
}
if (stype == SType.NOT_DEFINED || stype == type)
{
return;
}
}
type = SType.NOT_DEFINED;
body = string.Empty;
}
private static void PrfTabAd(string key, string templs)
{
PrfTab.Add(key, Lib.ToLat(templs.ToLower()));
}
public void Ad(SType stype, string str)
{
dpStr.Add(stype, str);
str = Lib.ToLat(str).ToLower().Replace(" ", "");
dpar.Add(stype, str);
}
public void UT_Parameter_Test()
{
var utp = new Par("{4}");
Assert.AreEqual(utp.ptype.ToString(), "String");
Assert.AreEqual(utp.tx, "");
Assert.AreEqual(utp.par.ToString(), "4");
utp = new Par(string.Empty);
Assert.AreEqual(utp.ptype, ParType.ANY);
Assert.AreEqual((string)utp.par, "");
Assert.AreEqual(utp.tx, "");
utp = new Par("Ab{123}cD");
Assert.AreEqual(utp.ptype, ParType.String);
Assert.AreEqual((string)utp.par, "123");
Assert.AreEqual(utp.tx, "ab");
utp = new Par("текст");
Assert.AreEqual(utp.ptype, ParType.String);
Assert.AreEqual(utp.tx, Lib.ToLat("текст"));
Assert.AreEqual((string)utp.par, utp.tx);
utp = new Par("x{3");
Assert.AreEqual((string)utp.par, "x{3");
Assert.AreEqual(utp.tx, (string)utp.par);
utp = new Par("def}fg");
Assert.AreEqual((string)utp.par, "def}fg");
Assert.AreEqual(utp.tx, (string)utp.par);
utp = new Par("Da{34{85}uy");
Assert.AreEqual(utp.tx, "da");
Assert.AreEqual((string)utp.par, "3485"); // поскольку внутреняя { стирается
//---- str with ':'
utp = new Par("M: B{1}");
Assert.AreEqual(utp.tx, "b");
Assert.AreEqual((string)utp.par, "1");
utp = new Par("проф: текст*");
Assert.AreEqual(utp.tx, "тeкcт*");
Assert.AreEqual((string)utp.par, utp.tx);
//---- str with ';'
utp = new Par("M: B{1};");
Assert.AreEqual(utp.tx, "b");
Assert.AreEqual((string)utp.par, "1");
utp = new Par("M: B{1}; and other ;");
Assert.AreEqual(utp.tx, "b");
Assert.AreEqual((string)utp.par, "1");
//---- getParType test
utp = new Par("цена: {d~3}");
Assert.AreEqual(utp.ptype, ParType.Double);
Assert.AreEqual((string)utp.par, "3");
Assert.AreEqual(pType("{2}"), ParType.String);
Assert.AreEqual(pType("{s~2}"), ParType.String);
Assert.AreEqual(pType("{i~4}"), ParType.Integer);
Assert.AreEqual(pType("{d~3}"), ParType.Double);
Assert.AreEqual(pType("{digital~3}"), ParType.Double);
Assert.AreEqual(pType("текст{i~1}b{d~2,2}ff"), ParType.Integer);
Assert.AreEqual(pType("другой текст"), ParType.String);
Assert.AreEqual(pType(""), ParType.ANY);
}