int TubeFromWire::CreateTube(NXOpen::Part *workPart, NXString outerDiameter, Routing::SplinePathBuilder *spline) //Ek
{
Features::Feature *nullFeatures_Feature(NULL);
// создаем объект трубы как указатель
//this = workPart->Features()->CreateTubeBuilder(nullFeatures_Feature);
this->SetTolerance(0.001); // припуск
this->OuterDiameter()->SetRightHandSide(outerDiameter); //внешний диаметр
this->InnerDiameter()->SetRightHandSide(INNER_DIAMETER); //внутренний диаметр
this->BooleanOption()->SetType(GeometricUtilities::BooleanOperation::BooleanTypeCreate); // булевы операции
this->PathSection()->SetDistanceTolerance(DISTANCE_TOLERANCE_TUBE); // допуск
this->PathSection()->SetChainingTolerance(CHAINING_TOLERANCE_TUBE); // допуск
// про булевы операции
std::vector<Body *> targetBodies1(1);
Body *nullBody(NULL);
targetBodies1[0] = nullBody;
this->BooleanOption()->SetTargetBodies(targetBodies1);
this->PathSection()->SetAllowedEntityTypes(Section::AllowTypesOnlyCurves); // вывод "ќдин сегмент"
// создаем из Curve объект CurveDumbRule,который потом добавим в объект трубы
Curve *curve1;
curve1 = spline->GetRouteSegment();
std::vector<IBaseCurve *> curves1(1);
Routing::SplineSegment *splineSegment1(dynamic_cast<Routing::SplineSegment *>(spline->GetRouteSegment()));
curves1[0] = splineSegment1;
CurveDumbRule *curveDumbRule1;
curveDumbRule1 = workPart->ScRuleFactory()->CreateRuleBaseCurveDumb(curves1);
//CurveDumbRule *curveDumbRule1;
//curveDumbRule1 = workPart->ScRuleFactory()->CreateRuleBaseCurveDumb(curve1);
this->PathSection()->AllowSelfIntersection(true);
std::vector<SelectionIntentRule *> rules1(1);
rules1[0] = curveDumbRule1;
NXObject *nullNXObject(NULL);
Point3d helpPoint1(-1711.72322949462, 778.153286292641, 0.0);
this->PathSection()->AddToSection(rules1, splineSegment1, nullNXObject, nullNXObject, helpPoint1, Section::ModeCreate, false);
//Session::UndoMarkId markId4;
//markId4 = theSession->SetUndoMark(Session::MarkVisibilityInvisible, "Tube");
NXObject *nXObject1;
nXObject1 = this->Commit();
return 0;
}
void EraRulesTest::testAPIs() {
const char * calTypes[] = {
"gregorian",
//"iso8601",
"buddhist",
"chinese",
"coptic",
"dangi",
"ethiopic",
"ethiopic-amete-alem",
"hebrew",
"indian",
"islamic",
"islamic-civil",
"islamic-rgsa",
"islamic-tbla",
"islamic-umalqura",
"japanese",
"persian",
"roc",
//"unknown",
NULL
};
for (int32_t i = 0; calTypes[i] != NULL; i++) {
UErrorCode status = U_ZERO_ERROR;
const char *calId = calTypes[i];
LocalPointer<EraRules> rules1(EraRules::createInstance(calId, FALSE, status));
if (U_FAILURE(status)) {
errln(UnicodeString("Era rules for ") + calId + " is not available.");
continue;
}
LocalPointer<EraRules> rules2(EraRules::createInstance(calId, TRUE, status));
if (U_FAILURE(status)) {
errln(UnicodeString("Era rules for ") + calId + " (including tentative eras) is not available.");
continue;
}
int32_t numEras1 = rules1->getNumberOfEras();
if (numEras1 <= 0) {
errln(UnicodeString("Number of era rules for ") + calId + " is " + numEras1);
}
int32_t numEras2 = rules2->getNumberOfEras();
if (numEras2 < numEras1) {
errln(UnicodeString("Number of era including tentative eras is fewer than one without tentative eras in calendar: ")
+ calId);
}
LocalPointer<Calendar> cal(Calendar::createInstance("en", status));
if (U_FAILURE(status)) {
errln("Failed to create a Calendar instance.");
continue;
}
int32_t currentIdx = rules1->getCurrentEraIndex();
int32_t currentYear = cal->get(UCAL_YEAR, status);
int32_t idx = rules1->getEraIndex(
currentYear, cal->get(UCAL_MONTH, status) + 1,
cal->get(UCAL_DATE, status), status);
if (U_FAILURE(status)) {
errln("Error while getting index of era.");
continue;
}
if (idx != currentIdx) {
errln(UnicodeString("Current era index:") + currentIdx + " is different from era index of now:" + idx
+ " in calendar:" + calId);
}
int32_t eraStartYear = rules1->getStartYear(currentIdx, status);
if (U_FAILURE(status)) {
errln(UnicodeString("Failed to get the start year of era index: ") + currentIdx + " in calendar: " + calId);
}
if (currentYear < eraStartYear) {
errln(UnicodeString("Current era's start year is after the current year in calendar:") + calId);
}
}
}
void parser(action *lexems, int size)
{
stack<StackType> stackMemory;
StackType buf;
buf.code = S;
buf.name = "";
stackMemory.push(buf);
int i = 0;
while(!stackMemory.empty())
{
bool flag = false, f = false;
buf = stackMemory.top();
if(i < size -1 ) print_el(array[i]), cout<<" ", print_el(array[i+1]);
else print_el(array[i]);
cout<<" ? ";
print_stack(stackMemory);
stackMemory.pop();
// cout<<" "<<lexems[i].id_name<<""<<endl;
if(lexems[i].code == buf.code)
{
if(lexems[i].code == id || lexems[i].code == lable) f = true, i++;
else if(lexems[i].id_name == buf.name) f = true, i++;
}
else
switch(buf.code)
{
f = false;
case S:
if(lexems[i].code == keyword && lexems[i].id_name == "$") return;
if(lexems[i].code == semicolon ) rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "dim" ) rules1(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "set") rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "do") rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "for") rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "if") rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "cin") rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "cout") rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "goto") rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "fail") rules2(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "select") rules2(stackMemory), f = true;
if(lexems[i].code == lable) rules2(stackMemory), f = true;
if(!f) throw InvalidBegin();
break;
case X:
if(lexems[i].code == keyword && lexems[i].id_name == "dim" ) rules3(stackMemory), f = true;
if(!f) throw InvalidDeclaringVariables();
break;
case X1:
if(lexems[i].code == semicolon)
{
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "$" ) rules6(stackMemory), f = true;
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "dim" ) rules7(stackMemory), f = true;
if(!f) rules8(stackMemory), f = true;
//if(lexems[i+1].code == keyword && lexems[i+1].id_name == "set") rules8(stackMemory), f = true;
// if(lexems[i+1].code != keyword) rules8(stackMemory), f = true;
//else rules8(stackMemory), f = true;
}
if(!f) throw InvalidType();
break;
case G:
if(lexems[i].code == id)
{
f = true;
if(lexems[i+1].code == coma) rules10(stackMemory);
else rules9(stackMemory);
}
if(!f) throw InvalidDeclaring();
break;
case TYPE:
if(lexems[i].code == keyword)
{
if(lexems[i].id_name == "BV") rules5(stackMemory), f = true;
if(lexems[i].id_name == "INT") rules4(stackMemory), f = true;
}
if(!f) throw InvalidType();
break;
case P:
if(lexems[i].code == semicolon )
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "$" ) rules11(stackMemory), f = true;
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "case" ) rules11(stackMemory), f = true;
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "ni" ) rules11(stackMemory), f = true;
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "otherwise" ) rules11(stackMemory), f = true;
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "while" ) rules11(stackMemory), f = true;
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "od" ) rules11(stackMemory), f = true;
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "else" ) rules11(stackMemory), f = true;
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "fi" ) rules11(stackMemory), f = true;
if(!f) rules12(stackMemory), f = true;
if(!f) throw InvalidEnd();
break;
case O:
if(lexems[i].code == semicolon )rules13(stackMemory), f = true;
// if(lexems[i].code == keyword && lexems[i].id_name == "case") rules13(stackMemory), f = true;
// if(lexems[i].code == keyword && lexems[i].id_name == "otherwise") rules13(stackMemory), f = true;
// if(lexems[i].code == keyword && lexems[i].id_name == "ni") rules13(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "set") rules14(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "do") rules15(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "for") rules27(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "if") rules30(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "cin") rules33(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "cout") rules36(stackMemory), f = true;
if(lexems[i].code == lable)
if(lexems[i+1].code == keyword && lexems[i+1].id_name == "$") rules39(stackMemory), f = true;
else rules40(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "goto") rules41(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "fail")
if(lexems[i+1].code == semicolon) rules42(stackMemory), f = true;
else rules43(stackMemory), f = true;
// cout<<lexems[i].id_name<<endl;
if(lexems[i].code == keyword && lexems[i].id_name == "select") rules44(stackMemory), f = true;
if(!f) throw InvalidOperator();
break;
case W:
if(lexems[i].code == semicolon) rules16(stackMemory), f = true;
if(lexems[i].code == lable) rules16(stackMemory), f = true;
if(lexems[i].code == keyword)
{
if(lexems[i].id_name == "set" || lexems[i].id_name == "do" || lexems[i].id_name == "for" ) rules16(stackMemory), f = true;
if(lexems[i].id_name == "cin" || lexems[i].id_name == "cout" ) rules16(stackMemory), f = true;
if(lexems[i].id_name == "while") rules17(stackMemory), f = true;
if(lexems[i].code == lable)rules16(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "goto") rules16(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "fail") rules16(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "select") rules16(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "if") rules16(stackMemory), f = true;
}
if(!f) throw InvalidOperatorWhile();
break;
case W1:
if(lexems[i].code == semicolon) rules18(stackMemory), f = true;
if(lexems[i].code == lable) rules18(stackMemory), f = true;
if(lexems[i].code == keyword)
{
if(lexems[i].id_name == "set" || lexems[i].id_name == "do"
|| lexems[i].id_name == "for" || lexems[i].id_name == "cout"
|| lexems[i].id_name == "cin" ) rules18(stackMemory), f = true;
if(lexems[i].id_name == "goto") rules18(stackMemory), f = true;
if(lexems[i].id_name == "if") rules18(stackMemory), f = true;
if(lexems[i].id_name == "fail") rules18(stackMemory), f = true;
if(lexems[i].id_name == "select") rules18(stackMemory), f = true;
if(lexems[i].id_name == "od") rules19(stackMemory), f = true;
}
if(!f) throw InvalidOperatorWhile();
break;
case T:
if(lexems[i].code == id || lexems[i].code == CONST
|| lexems[i].code == lbr || lexems[i].code == otr
|| lexems[i].code == lfs || lexems[i].code == rs
|| lexems[i].code == ls) rules20(stackMemory), f = true;
if(!f) throw InvalidTest();
break;
case T1:
if(lexems[i].code == Equal) rules21(stackMemory), f = true;
if(lexems[i].code == not_equal) rules22(stackMemory), f = true;
if(lexems[i].code == more) rules23(stackMemory), f = true;
if(lexems[i].code == Less) rules24(stackMemory), f = true;
if(lexems[i].code == more_or_equal) rules25(stackMemory), f = true;
if(lexems[i].code == less_or_equal) rules26(stackMemory), f = true;
if(!f) throw InvalidRatio();
break;
case F:
if(lexems[i].code == keyword && lexems[i].id_name == "by") rules28(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "do") rules29(stackMemory), f = true;
if(!f) throw InvalidOperatorFor();
break;
case N:
if(lexems[i].code == keyword && lexems[i].id_name == "else") rules31(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "fi") rules32(stackMemory), f = true;
if(!f) throw InvalidOperatorIf();
break;
case I:
if(lexems[i].code == semicolon ) rules34(stackMemory), f = true;
if(lexems[i].code == in ) rules35(stackMemory), f = true;
if(!f) throw InvalidOperatorCin();
break;
case U:
if(lexems[i].code == semicolon ) rules37(stackMemory), f = true;
if(lexems[i].code == out ) rules38(stackMemory), f = true;
if(!f) throw InvalidOperatorCout();
break;
case K:
if(lexems[i].code == keyword && lexems[i].id_name == "case") rules45(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "otherwise") rules46(stackMemory), f = true;
if(lexems[i].code == keyword && lexems[i].id_name == "ni") rules47(stackMemory), f = true;
if(!f) throw InvalidOperatorSelect();
break;
case E:
if(lexems[i].code == id || lexems[i].code == CONST
|| lexems[i].code == lbr || lexems[i].code == otr
|| lexems[i].code == lfs || lexems[i].code == rs
|| lexems[i].code == ls) rules48(stackMemory), f = true;
if(!f) throw InvalidExpression();
break;
case A:
if(lexems[i].code == id || lexems[i].code == CONST
|| lexems[i].code == lbr || lexems[i].code == otr
|| lexems[i].code == lfs || lexems[i].code == rs
|| lexems[i].code == ls) rules49(stackMemory), f = true;
if(!f) throw InvalidExpression();
break;
case B:
if(lexems[i].code == id || lexems[i].code == CONST
|| lexems[i].code == lbr || lexems[i].code == otr
|| lexems[i].code == lfs || lexems[i].code == rs
|| lexems[i].code == ls) rules50(stackMemory), f = true;
if(!f) throw InvalidExpression();
break;
case D:
if(lexems[i].code == id || lexems[i].code == CONST
|| lexems[i].code == lbr || lexems[i].code == otr
|| lexems[i].code == lfs || lexems[i].code == rs
|| lexems[i].code == ls) rules51(stackMemory), f = true;
if(!f) throw InvalidExpression();
break;
case H:
if(lexems[i].code == id || lexems[i].code == CONST
|| lexems[i].code == lbr || lexems[i].code == otr
|| lexems[i].code == lfs || lexems[i].code == rs
|| lexems[i].code == ls) rules52(stackMemory), f = true;
if(!f) throw InvalidExpression();
break;
case J:
if(lexems[i].code == id || lexems[i].code == CONST
|| lexems[i].code == lbr || lexems[i].code == otr
|| lexems[i].code == lfs ) rules55(stackMemory), f = true;
if(lexems[i].code == rs) rules53(stackMemory), f = true;
if(lexems[i].code == ls) rules54(stackMemory), f = true;
if(!f) throw InvalidExpression();
break;
case L:
if(lexems[i].code == id || lexems[i].code == CONST
|| lexems[i].code == lbr || lexems[i].code == otr) rules57(stackMemory), f = true;
if(lexems[i].code == lfs) rules56(stackMemory), f = true;
if(!f) throw InvalidExpression();
break;
case Z:
if(lexems[i].code == id) rules59(stackMemory), f = true;
if(lexems[i].code == CONST) rules60(stackMemory), f = true;
if(lexems[i].code == lbr) rules61(stackMemory), f = true;
if(lexems[i].code == otr) rules58(stackMemory), f = true;
if(!f) throw InvalidExpression();
break;
case ID:
if(lexems[i].code == id)
{
if(lexems[i+1].code == AND) rules77(stackMemory), f = true;
if(lexems[i+1].code == OR) rules78(stackMemory), f = true;
if(lexems[i+1].code == Xor) rules79(stackMemory), f = true;
if(lexems[i+1].code == ssh) rules80(stackMemory), f = true;
if(lexems[i+1].code == sl) rules81(stackMemory), f = true;
if(lexems[i+1].code == conc) rules82(stackMemory), f = true;
if(lexems[i+1].code == scolar) rules83(stackMemory), f = true;
if(lexems[i+1].code == sp) rules84(stackMemory), f = true;
if(lexems[i+1].code == multy) rules85(stackMemory), f = true;
if(lexems[i+1].code == DEV) rules86(stackMemory), f = true;
if(lexems[i+1].code == MOD) rules87(stackMemory), f = true;
if(lexems[i+1].code == add) rules88(stackMemory), f = true;
if(lexems[i+1].code == sub) rules89(stackMemory), f = true;
if(!f) rules90(stackMemory), f = true;
}
if(!f) throw InvalidExpression();
break;
case C:
if(lexems[i].code == CONST)
{
if(lexems[i+1].code == AND) rules92(stackMemory), f = true;
if(lexems[i+1].code == OR) rules93(stackMemory), f = true;
if(lexems[i+1].code == Xor) rules94(stackMemory), f = true;
if(lexems[i+1].code == ssh) rules95(stackMemory), f = true;
if(lexems[i+1].code == sl) rules96(stackMemory), f = true;
if(lexems[i+1].code == conc) rules97(stackMemory), f = true;
if(lexems[i+1].code == scolar) rules98(stackMemory), f = true;
if(lexems[i+1].code == sp) rules99(stackMemory), f = true;
if(lexems[i+1].code == multy) rules100(stackMemory), f = true;
if(lexems[i+1].code == DEV) rules101(stackMemory), f = true;
if(lexems[i+1].code == MOD) rules102(stackMemory), f = true;
if(lexems[i+1].code == add) rules103(stackMemory), f = true;
if(lexems[i+1].code == sub) rules104(stackMemory), f = true;
if(!f) rules105(stackMemory), f = true;
}
if(!f) throw InvalidExpression();
break;
case SH:
if(lexems[i].code == rbr)
{
if(lexems[i+1].code == AND) rules62(stackMemory), f = true;
if(lexems[i+1].code == OR) rules63(stackMemory), f = true;
if(lexems[i+1].code == Xor) rules64(stackMemory), f = true;
if(lexems[i+1].code == ssh) rules65(stackMemory), f = true;
if(lexems[i+1].code == sl) rules66(stackMemory), f = true;
if(lexems[i+1].code == conc) rules67(stackMemory), f = true;
if(lexems[i+1].code == scolar) rules68(stackMemory), f = true;
if(lexems[i+1].code == sp) rules69(stackMemory), f = true;
if(lexems[i+1].code == multy) rules70(stackMemory), f = true;
if(lexems[i+1].code == DEV) rules71(stackMemory), f = true;
if(lexems[i+1].code == MOD) rules72(stackMemory), f = true;
if(lexems[i+1].code == add) rules73(stackMemory), f = true;
if(lexems[i+1].code == sub) rules74(stackMemory), f = true;
if(!f) rules75(stackMemory), f = true;
}
if(!f) throw InvalidExpression();
break;
case G1:
if(lexems[i].code == id)
{
f = true;
if(lexems[i+1].code == coma) rules107(stackMemory);
else rules106(stackMemory);
}
if(!f) throw InvalidDeclaring();
break;
default: cout<<"ERRRRORRRRR"<<endl; return;
}
}
cout<<lexems[i].id_name<<""<<endl;
if(lexems[i].id_name == "$" && stackMemory.empty()) cout<<"acc"<<endl;
else cout<<"fail"<<endl;
}
