[occt.git] / src / MoniTool / MoniTool_CaseData.cxx

// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

#include <MoniTool_CaseData.ixx>
#include <Standard_Failure.hxx>
#include <TCollection_AsciiString.hxx>
#include <TopoDS_HShape.hxx>
#include <Geom_CartesianPoint.hxx>
#include <Geom2d_CartesianPoint.hxx>

#include <TopAbs.hxx>
//#include <GeomTools.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <OSD_Timer.hxx>

// definitions
#include <Dico_DictionaryOfInteger.hxx>
#include <Dico_DictionaryOfTransient.hxx>

static Handle(Dico_DictionaryOfInteger)& defchecks()
{
  static Handle(Dico_DictionaryOfInteger) defch;
  if (defch.IsNull()) defch = new Dico_DictionaryOfInteger();
  return defch;
}

static Handle(Dico_DictionaryOfTransient)& defmess()
{
  static Handle(Dico_DictionaryOfTransient) defms;
  if (defms.IsNull()) defms = new Dico_DictionaryOfTransient();
  return defms;
}


static Standard_Boolean stachr = Standard_False;

//static OSD_Timer chrono;
// because merdouille link dynamique & perf, ne creer le static qu au 1er usage
static OSD_Timer& chrono() {
  static OSD_Timer chr;
  return chr;
}


    MoniTool_CaseData::MoniTool_CaseData
  (const Standard_CString caseid, const Standard_CString name)
    : thesubst (0) , thecase (caseid) , thename (name)  
      {  thecheck = DefCheck(caseid);  }

    void  MoniTool_CaseData::SetCaseId (const Standard_CString caseid)
      {  thecase.Clear();  thecase.AssignCat (caseid);  thecheck = DefCheck(caseid);  thesubst = 0;  }

    void  MoniTool_CaseData::SetName   (const Standard_CString name)
      {  thename.Clear();  thename.AssignCat (name);  thesubst = 0;  }

    Standard_CString  MoniTool_CaseData::CaseId () const
      {  return thecase.ToCString();  }

    Standard_CString  MoniTool_CaseData::Name   () const
      {  return thename.ToCString();  }


    Standard_Boolean  MoniTool_CaseData::IsCheck   () const
      {  return  (thecheck > 0);  }

    Standard_Boolean  MoniTool_CaseData::IsWarning () const
      {  return (thecheck == 1);  }

    Standard_Boolean  MoniTool_CaseData::IsFail    () const
      {  return (thecheck == 2);  }

    void  MoniTool_CaseData::ResetCheck ()
      {  thecheck = 0;  }

    void  MoniTool_CaseData::SetWarning ()
      {  thecheck = 1;  }

    void  MoniTool_CaseData::SetFail    ()
      {  thecheck = 2;  }

//  ####    DATA    ####

    void  MoniTool_CaseData::SetChange  ()
      {  thesubst = -1;   }

    void  MoniTool_CaseData::SetReplace (const Standard_Integer num)
      {  thesubst = num;  }

    void  MoniTool_CaseData::AddData
  (const Handle(Standard_Transient)& val,
   const Standard_Integer kind, const Standard_CString name)
{
  TCollection_AsciiString aname(name);
  Standard_Integer subs = thesubst;

//  SetChange (calculer la position d apres Name)
  if (thesubst < 0) {
    if (name[0] != '\0') subs = NameNum (name);
  }
//  SetChange / SetReplace
  if (subs > 0 && subs <= thedata.Length()) {
    thedata.SetValue (subs,val);
    thekind.SetValue (subs,kind);
    if (aname.Length() > 0) thednam.SetValue (subs,aname);
//  Ajout Normal
  } else {
    thedata.Append (val);
    thekind.Append (kind);
    thednam.Append (aname);
  }
  thesubst = 0;
}

    void  MoniTool_CaseData::AddRaised (const Standard_CString name)
      {  AddData ( Standard_Failure::Caught(),1,name);  }

    void  MoniTool_CaseData::AddShape
  (const TopoDS_Shape& sh, const Standard_CString name)
      {  AddData ( new TopoDS_HShape(sh), 4,name);  }

    void  MoniTool_CaseData::AddXYZ
  (const gp_XYZ& aXYZ, const Standard_CString name)
      {  AddData ( new Geom_CartesianPoint (aXYZ), 5,name);  }

    void  MoniTool_CaseData::AddXY
  (const gp_XY&  aXY, const Standard_CString name)
      {  AddData ( new Geom2d_CartesianPoint (aXY), 6,name);  }

    void  MoniTool_CaseData::AddReal
  (const Standard_Real val, const Standard_CString name)
      {  AddData ( new Geom2d_CartesianPoint (val,0.), 8,name);  }

    void  MoniTool_CaseData::AddReals
 (const Standard_Real v1, const Standard_Real v2, const Standard_CString name)
      {  AddData ( new Geom2d_CartesianPoint (v1,v2), 7,name);  }

    void  MoniTool_CaseData::AddCPU
  (const Standard_Real lastCPU, const Standard_Real curCPU,
   const Standard_CString name)
{
  Standard_Real cpu = curCPU;
  if (cpu == 0.) {
    Standard_Real sec;  Standard_Integer i1,i2;
    chrono().Show (sec,i1,i2,cpu);
  }
  cpu = cpu - lastCPU;
  AddData ( new Geom2d_CartesianPoint (cpu,0.), 9,name);
}

    Standard_Real  MoniTool_CaseData::GetCPU () const
{
  if (!stachr) { chrono().Start(); stachr = Standard_True; }
  Standard_Real sec,cpu;  Standard_Integer i1,i2;
  chrono().Show (sec,i1,i2,cpu);
  return cpu;
}

    Standard_Boolean  MoniTool_CaseData::LargeCPU
  (const Standard_Real maxCPU,
   const Standard_Real lastCPU, const Standard_Real curCPU) const
{
  Standard_Real cpu = curCPU;
  if (cpu == 0.) {
    Standard_Real sec;  Standard_Integer i1,i2;
    chrono().Show (sec,i1,i2,cpu);
  }
  cpu = cpu - lastCPU;
  return (cpu >= maxCPU);
}

    void  MoniTool_CaseData::AddGeom
  (const Handle(Standard_Transient)& val, const Standard_CString name)
      {  AddData (val,3,name);  }

    void  MoniTool_CaseData::AddEntity
  (const Handle(Standard_Transient)& val, const Standard_CString name)
      {  AddData (val,2,name);  }

    void  MoniTool_CaseData::AddText
  (const Standard_CString text, const Standard_CString name)
      {  AddData (new TCollection_HAsciiString(text),10,name);  }

    void  MoniTool_CaseData::AddInteger
  (const Standard_Integer val, const Standard_CString name)
{
  Standard_Real rval = val;
  AddData ( new Geom2d_CartesianPoint (rval,0.), 11,name);
}

    void  MoniTool_CaseData::AddAny
  (const Handle(Standard_Transient)& val, const Standard_CString name)
      {  AddData (val,0,name);  }


    void  MoniTool_CaseData::RemoveData (const Standard_Integer num)
{
  if (num < 1 || num > thedata.Length()) return;
  thedata.Remove(num);  thekind.Remove(num);  thednam.Remove(num);
}

//    ####    INTERROGATIONS    ####

    Standard_Integer  MoniTool_CaseData::NbData () const
      {  return thedata.Length();  }

    Handle(Standard_Transient)  MoniTool_CaseData::Data
  (const Standard_Integer nd) const
{
  Handle(Standard_Transient) val;
  if (nd < 1 || nd > thedata.Length()) return val;
  return thedata (nd);
}

Standard_Boolean  MoniTool_CaseData::GetData
  (const Standard_Integer nd, const Handle(Standard_Type)& type,
   Handle(Standard_Transient)& val) const
{
  if (type.IsNull()) return Standard_False;
  if (nd < 1 || nd > thedata.Length()) return Standard_False;
  Handle(Standard_Transient) v = thedata (nd);
  if (v.IsNull()) return Standard_False;
  if (!v->IsKind(type)) return Standard_False;
  val = v;
  return Standard_True;
}

    Standard_Integer  MoniTool_CaseData::Kind
  (const Standard_Integer nd) const
{
  if (nd < 1 || nd > thekind.Length()) return 0;
  return thekind (nd);
}


static  const TCollection_AsciiString&  nulname ()
{
  static TCollection_AsciiString nuln;
  return nuln;
}

    const TCollection_AsciiString&  MoniTool_CaseData::Name
  (const Standard_Integer nd) const
{
  if (nd < 1 || nd > thednam.Length()) return nulname();
  return thednam(nd);
}

static Standard_Integer NameKind (const Standard_CString name)
{
  char n0 = name[0];
  if (n0 == 'A' && name[1] == 'N' && name[2] == 'Y' && name[3] == '\0') return 0;
  if (n0 == 'E') {
    if (name[1] == 'X' && name[2] == '\0') return 1;
    if (name[1] == 'N' && name[2] == '\0') return 2;
    return 0;
  }
  if (n0 == 'G' && name[1] == '\0') return 3;
  if (n0 == 'S' && name[1] == 'H' && name[2] == '\0') return 4;
  if (n0 == 'X' && name[1] == 'Y') {
    if (name[2] == 'Z' && name[3] == '\0') return 5;
    if (name[2] == '\0') return 6;
  }
  if (n0 == 'U' && name[1] == 'V' && name[2] == '\0') return 6;
  if (n0 == 'R') {
    if (name[1] == '\0') return 8;
    if (name[1] == 'R' && name[2] == '\0') return 7;
  }
  if (n0 == 'C' && name[1] == 'P' && name[2] == 'U' && name[3] == '\0') return 9;
  if (n0 == 'T' && name[1] == '\0') return 10;
  if (n0 == 'I' && name[1] == '\0') return 11;

  return 0;
}

static Standard_Integer NameRank (const Standard_CString name)
{
  for (Standard_Integer i = 0; name[i] != '\0'; i ++) {
    if (name[i] == ':' && name[i+1] != '\0') return atoi(&name[i+1]);
  }
  return 1;
}

    Standard_Integer  MoniTool_CaseData::NameNum
  (const Standard_CString name) const
{
  if (!name || name[0] == '\0') return 0;
  Standard_Integer nd, nn = 0, nb = NbData();
  for (nd = 1; nd <= nb; nd ++) {
    if (thednam(nd).IsEqual(name)) return nd;
  }

  Standard_Integer kind = NameKind (name);
  if (kind < 0) return 0;
  Standard_Integer num  = NameRank (name);

  for (nd = 1; nd <= nb; nd ++) {
    if (thekind(nd) == kind) {
      nn ++;
      if (nn == num) return nd;
    }
  }
  return 0;
}


//  ####    RETOUR DES VALEURS    ####

    TopoDS_Shape  MoniTool_CaseData::Shape
  (const Standard_Integer nd) const
{
  TopoDS_Shape sh;
  Handle(TopoDS_HShape) hs = Handle(TopoDS_HShape)::DownCast (Data(nd));
  if (!hs.IsNull()) sh = hs->Shape();
  return sh;
}

    Standard_Boolean  MoniTool_CaseData::XYZ
  (const Standard_Integer nd, gp_XYZ& val) const
{
  Handle(Geom_CartesianPoint) p = Handle(Geom_CartesianPoint)::DownCast(Data(nd));
  if (p.IsNull()) return Standard_False;
  val = p->Pnt().XYZ();
  return Standard_True;
}

    Standard_Boolean   MoniTool_CaseData::XY
  (const Standard_Integer nd, gp_XY& val) const
{
  Handle(Geom2d_CartesianPoint) p = Handle(Geom2d_CartesianPoint)::DownCast(Data(nd));
  if (p.IsNull()) return Standard_False;
  val = p->Pnt2d().XY();
  return Standard_True;
}

    Standard_Boolean   MoniTool_CaseData::Reals
  (const Standard_Integer nd,
   Standard_Real& v1, Standard_Real& v2) const
{
  Handle(Geom2d_CartesianPoint) p = Handle(Geom2d_CartesianPoint)::DownCast(Data(nd));
  if (p.IsNull()) return Standard_False;
  v1 = p->X();  v2 = p->Y();
  return Standard_True;
}


    Standard_Boolean   MoniTool_CaseData::Real
  (const Standard_Integer nd,
   Standard_Real& val) const
{
  Handle(Geom2d_CartesianPoint) p = Handle(Geom2d_CartesianPoint)::DownCast(Data(nd));
  if (p.IsNull()) return Standard_False;
  val = p->X();
  return Standard_True;
}

    Standard_Boolean   MoniTool_CaseData::Text
  (const Standard_Integer nd,
   Standard_CString& text) const
{
  Handle(TCollection_HAsciiString) t = Handle(TCollection_HAsciiString)::DownCast(Data(nd));
  if (t.IsNull()) return Standard_False;
  text = t->ToCString();
  return Standard_True;
}

    Standard_Boolean   MoniTool_CaseData::Integer
  (const Standard_Integer nd,
   Standard_Integer& val) const
{
  Handle(Geom2d_CartesianPoint) p = Handle(Geom2d_CartesianPoint)::DownCast(Data(nd));
//  if (p.IsNull()) return Standard_False;
  if (thekind(nd) != 11) return Standard_False;
  Standard_Real rval = p->X();
  val = (Standard_Integer)rval;
  return Standard_True;
}


//  ####    MESSAGES ET DEFINITIONS    ####

Message_Msg  MoniTool_CaseData::Msg () const
{
  Standard_CString defm = DefMsg (thecase.ToCString());

//  A REPRENDRE COMPLETEMENT !  Il faut analyser defm = mescode + variables
  Message_Msg mess;
  mess.Set (defm);

  return mess;
}


    void  MoniTool_CaseData::SetDefWarning (const Standard_CString acode)
      {  defchecks()->SetItem (acode,1);  }

    void  MoniTool_CaseData::SetDefFail (const Standard_CString acode)
      {  defchecks()->SetItem (acode,2);  }

    Standard_Integer  MoniTool_CaseData::DefCheck (const Standard_CString acode)
{
  Standard_Integer val;
  if (!defchecks()->GetItem (acode,val)) val = 0;
  return val;
}


    void  MoniTool_CaseData::SetDefMsg
  (const Standard_CString casecode, const Standard_CString mesdef)
{
  Handle(TCollection_HAsciiString) str = new TCollection_HAsciiString (mesdef);
  defmess()->SetItem (casecode,str);
}

    Standard_CString MoniTool_CaseData::DefMsg (const Standard_CString casecode)
{
  //Standard_CString mesd;
  Handle(TCollection_HAsciiString) str;
  if (!defmess()->GetItem (casecode,str)) return "";
  if (str.IsNull()) return "";
  return str->ToCString();
}
Commit	Line	Data
b311480e	1	// Copyright (c) 1999-2012 OPEN CASCADE SAS
	2	//
	3	// The content of this file is subject to the Open CASCADE Technology Public
	4	// License Version 6.5 (the "License"). You may not use the content of this file
	5	// except in compliance with the License. Please obtain a copy of the License
	6	// at http://www.opencascade.org and read it completely before using this file.
	7	//
	8	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	9	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	10	//
	11	// The Original Code and all software distributed under the License is
	12	// distributed on an "AS IS" basis, without warranty of any kind, and the
	13	// Initial Developer hereby disclaims all such warranties, including without
	14	// limitation, any warranties of merchantability, fitness for a particular
	15	// purpose or non-infringement. Please see the License for the specific terms
	16	// and conditions governing the rights and limitations under the License.
	17
7fd59977	18	#include <MoniTool_CaseData.ixx>
	19	#include <Standard_Failure.hxx>
	20	#include <TCollection_AsciiString.hxx>
	21	#include <TopoDS_HShape.hxx>
	22	#include <Geom_CartesianPoint.hxx>
	23	#include <Geom2d_CartesianPoint.hxx>
	24
	25	#include <TopAbs.hxx>
	26	//#include <GeomTools.hxx>
	27	#include <TCollection_HAsciiString.hxx>
	28	#include <Geom2d_Curve.hxx>
	29	#include <Geom_Curve.hxx>
	30	#include <Geom_Surface.hxx>
	31	#include <OSD_Timer.hxx>
	32
	33	// definitions
	34	#include <Dico_DictionaryOfInteger.hxx>
	35	#include <Dico_DictionaryOfTransient.hxx>
	36
	37	static Handle(Dico_DictionaryOfInteger)& defchecks()
	38	{
	39	static Handle(Dico_DictionaryOfInteger) defch;
	40	if (defch.IsNull()) defch = new Dico_DictionaryOfInteger();
	41	return defch;
	42	}
	43
	44	static Handle(Dico_DictionaryOfTransient)& defmess()
	45	{
	46	static Handle(Dico_DictionaryOfTransient) defms;
	47	if (defms.IsNull()) defms = new Dico_DictionaryOfTransient();
	48	return defms;
	49	}
	50
	51
	52	static Standard_Boolean stachr = Standard_False;
	53
	54	//static OSD_Timer chrono;
	55	// because merdouille link dynamique & perf, ne creer le static qu au 1er usage
	56	static OSD_Timer& chrono() {
	57	static OSD_Timer chr;
	58	return chr;
	59	}
	60
	61
	62	MoniTool_CaseData::MoniTool_CaseData
	63	(const Standard_CString caseid, const Standard_CString name)
	64	: thesubst (0) , thecase (caseid) , thename (name)
	65	{ thecheck = DefCheck(caseid); }
	66
	67	void MoniTool_CaseData::SetCaseId (const Standard_CString caseid)
	68	{ thecase.Clear(); thecase.AssignCat (caseid); thecheck = DefCheck(caseid); thesubst = 0; }
	69
	70	void MoniTool_CaseData::SetName (const Standard_CString name)
	71	{ thename.Clear(); thename.AssignCat (name); thesubst = 0; }
	72
	73	Standard_CString MoniTool_CaseData::CaseId () const
	74	{ return thecase.ToCString(); }
	75
	76	Standard_CString MoniTool_CaseData::Name () const
	77	{ return thename.ToCString(); }
	78
	79
	80	Standard_Boolean MoniTool_CaseData::IsCheck () const
	81	{ return (thecheck > 0); }
82
83	Standard_Boolean MoniTool_CaseData::IsWarning () const
84	{ return (thecheck == 1); }
85
86	Standard_Boolean MoniTool_CaseData::IsFail () const
87	{ return (thecheck == 2); }
88
89	void MoniTool_CaseData::ResetCheck ()
90	{ thecheck = 0; }
91
92	void MoniTool_CaseData::SetWarning ()
93	{ thecheck = 1; }
94
95	void MoniTool_CaseData::SetFail ()
96	{ thecheck = 2; }
97
98	// #### DATA ####
99
100	void MoniTool_CaseData::SetChange ()
101	{ thesubst = -1; }
102
103	void MoniTool_CaseData::SetReplace (const Standard_Integer num)
104	{ thesubst = num; }
105
106	void MoniTool_CaseData::AddData
107	(const Handle(Standard_Transient)& val,
108	const Standard_Integer kind, const Standard_CString name)
109	{
110	TCollection_AsciiString aname(name);
111	Standard_Integer subs = thesubst;
112
113	// SetChange (calculer la position d apres Name)
114	if (thesubst < 0) {
115	if (name[0] != '\0') subs = NameNum (name);
116	}
117	// SetChange / SetReplace
118	if (subs > 0 && subs <= thedata.Length()) {
119	thedata.SetValue (subs,val);
120	thekind.SetValue (subs,kind);
121	if (aname.Length() > 0) thednam.SetValue (subs,aname);
122	// Ajout Normal
123	} else {
124	thedata.Append (val);
125	thekind.Append (kind);
126	thednam.Append (aname);
127	}
128	thesubst = 0;
129	}
130
131	void MoniTool_CaseData::AddRaised (const Standard_CString name)
132	{ AddData ( Standard_Failure::Caught(),1,name); }
133
134	void MoniTool_CaseData::AddShape
135	(const TopoDS_Shape& sh, const Standard_CString name)
136	{ AddData ( new TopoDS_HShape(sh), 4,name); }
137
138	void MoniTool_CaseData::AddXYZ
139	(const gp_XYZ& aXYZ, const Standard_CString name)
140	{ AddData ( new Geom_CartesianPoint (aXYZ), 5,name); }
141
142	void MoniTool_CaseData::AddXY
143	(const gp_XY& aXY, const Standard_CString name)
144	{ AddData ( new Geom2d_CartesianPoint (aXY), 6,name); }
145
146	void MoniTool_CaseData::AddReal
147	(const Standard_Real val, const Standard_CString name)
148	{ AddData ( new Geom2d_CartesianPoint (val,0.), 8,name); }
149
150	void MoniTool_CaseData::AddReals
151	(const Standard_Real v1, const Standard_Real v2, const Standard_CString name)
152	{ AddData ( new Geom2d_CartesianPoint (v1,v2), 7,name); }
153
154	void MoniTool_CaseData::AddCPU
155	(const Standard_Real lastCPU, const Standard_Real curCPU,
156	const Standard_CString name)
157	{
158	Standard_Real cpu = curCPU;
159	if (cpu == 0.) {
160	Standard_Real sec; Standard_Integer i1,i2;
161	chrono().Show (sec,i1,i2,cpu);
162	}
163	cpu = cpu - lastCPU;
164	AddData ( new Geom2d_CartesianPoint (cpu,0.), 9,name);
165	}
166
167	Standard_Real MoniTool_CaseData::GetCPU () const
168	{
169	if (!stachr) { chrono().Start(); stachr = Standard_True; }
170	Standard_Real sec,cpu; Standard_Integer i1,i2;
171	chrono().Show (sec,i1,i2,cpu);
172	return cpu;
173	}
174
175	Standard_Boolean MoniTool_CaseData::LargeCPU
176	(const Standard_Real maxCPU,
177	const Standard_Real lastCPU, const Standard_Real curCPU) const
178	{
179	Standard_Real cpu = curCPU;
180	if (cpu == 0.) {
181	Standard_Real sec; Standard_Integer i1,i2;
182	chrono().Show (sec,i1,i2,cpu);
183	}
184	cpu = cpu - lastCPU;
185	return (cpu >= maxCPU);
186	}
187
188	void MoniTool_CaseData::AddGeom
189	(const Handle(Standard_Transient)& val, const Standard_CString name)
190	{ AddData (val,3,name); }
191
192	void MoniTool_CaseData::AddEntity
193	(const Handle(Standard_Transient)& val, const Standard_CString name)
194	{ AddData (val,2,name); }
195
196	void MoniTool_CaseData::AddText
197	(const Standard_CString text, const Standard_CString name)
198	{ AddData (new TCollection_HAsciiString(text),10,name); }
199
200	void MoniTool_CaseData::AddInteger
201	(const Standard_Integer val, const Standard_CString name)
202	{
203	Standard_Real rval = val;
204	AddData ( new Geom2d_CartesianPoint (rval,0.), 11,name);
205	}
206
207	void MoniTool_CaseData::AddAny
208	(const Handle(Standard_Transient)& val, const Standard_CString name)
209	{ AddData (val,0,name); }
210
211
212	void MoniTool_CaseData::RemoveData (const Standard_Integer num)
213	{
214	if (num < 1 \|\| num > thedata.Length()) return;
215	thedata.Remove(num); thekind.Remove(num); thednam.Remove(num);
216	}
217
218	// #### INTERROGATIONS ####
219
220	Standard_Integer MoniTool_CaseData::NbData () const
221	{ return thedata.Length(); }
222
223	Handle(Standard_Transient) MoniTool_CaseData::Data
224	(const Standard_Integer nd) const
225	{
226	Handle(Standard_Transient) val;
227	if (nd < 1 \|\| nd > thedata.Length()) return val;
228	return thedata (nd);
229	}
230
231	Standard_Boolean MoniTool_CaseData::GetData
232	(const Standard_Integer nd, const Handle(Standard_Type)& type,
233	Handle(Standard_Transient)& val) const
234	{
235	if (type.IsNull()) return Standard_False;
236	if (nd < 1 \|\| nd > thedata.Length()) return Standard_False;
237	Handle(Standard_Transient) v = thedata (nd);
238	if (v.IsNull()) return Standard_False;
239	if (!v->IsKind(type)) return Standard_False;
240	val = v;
241	return Standard_True;
242	}
243
244	Standard_Integer MoniTool_CaseData::Kind
245	(const Standard_Integer nd) const
246	{
247	if (nd < 1 \|\| nd > thekind.Length()) return 0;
248	return thekind (nd);
249	}
250
251
252	static const TCollection_AsciiString& nulname ()
253	{
254	static TCollection_AsciiString nuln;
255	return nuln;
256	}
257
258	const TCollection_AsciiString& MoniTool_CaseData::Name
259	(const Standard_Integer nd) const
260	{
261	if (nd < 1 \|\| nd > thednam.Length()) return nulname();
262	return thednam(nd);
263	}
264
265	static Standard_Integer NameKind (const Standard_CString name)
266	{
267	char n0 = name[0];
268	if (n0 == 'A' && name[1] == 'N' && name[2] == 'Y' && name[3] == '\0') return 0;
269	if (n0 == 'E') {
270	if (name[1] == 'X' && name[2] == '\0') return 1;
271	if (name[1] == 'N' && name[2] == '\0') return 2;
272	return 0;
273	}
274	if (n0 == 'G' && name[1] == '\0') return 3;
275	if (n0 == 'S' && name[1] == 'H' && name[2] == '\0') return 4;
276	if (n0 == 'X' && name[1] == 'Y') {
277	if (name[2] == 'Z' && name[3] == '\0') return 5;
278	if (name[2] == '\0') return 6;
279	}
280	if (n0 == 'U' && name[1] == 'V' && name[2] == '\0') return 6;
281	if (n0 == 'R') {
282	if (name[1] == '\0') return 8;
283	if (name[1] == 'R' && name[2] == '\0') return 7;
284	}
285	if (n0 == 'C' && name[1] == 'P' && name[2] == 'U' && name[3] == '\0') return 9;
286	if (n0 == 'T' && name[1] == '\0') return 10;
287	if (n0 == 'I' && name[1] == '\0') return 11;
288
289	return 0;
290	}
291
292	static Standard_Integer NameRank (const Standard_CString name)
293	{
294	for (Standard_Integer i = 0; name[i] != '\0'; i ++) {
295	if (name[i] == ':' && name[i+1] != '\0') return atoi(&name[i+1]);
296	}
297	return 1;
298	}
299
300	Standard_Integer MoniTool_CaseData::NameNum
301	(const Standard_CString name) const
302	{
303	if (!name \|\| name[0] == '\0') return 0;
304	Standard_Integer nd, nn = 0, nb = NbData();
305	for (nd = 1; nd <= nb; nd ++) {
306	if (thednam(nd).IsEqual(name)) return nd;
307	}
308
309	Standard_Integer kind = NameKind (name);
310	if (kind < 0) return 0;
311	Standard_Integer num = NameRank (name);
312
313	for (nd = 1; nd <= nb; nd ++) {
314	if (thekind(nd) == kind) {
315	nn ++;
316	if (nn == num) return nd;
317	}
318	}
319	return 0;
320	}
321
322
323	// #### RETOUR DES VALEURS ####
324
325	TopoDS_Shape MoniTool_CaseData::Shape
326	(const Standard_Integer nd) const
327	{
328	TopoDS_Shape sh;
329	Handle(TopoDS_HShape) hs = Handle(TopoDS_HShape)::DownCast (Data(nd));
330	if (!hs.IsNull()) sh = hs->Shape();
331	return sh;
332	}
333
334	Standard_Boolean MoniTool_CaseData::XYZ
335	(const Standard_Integer nd, gp_XYZ& val) const
336	{
337	Handle(Geom_CartesianPoint) p = Handle(Geom_CartesianPoint)::DownCast(Data(nd));
338	if (p.IsNull()) return Standard_False;
339	val = p->Pnt().XYZ();
340	return Standard_True;
341	}
342
343	Standard_Boolean MoniTool_CaseData::XY
344	(const Standard_Integer nd, gp_XY& val) const
345	{
346	Handle(Geom2d_CartesianPoint) p = Handle(Geom2d_CartesianPoint)::DownCast(Data(nd));
347	if (p.IsNull()) return Standard_False;
348	val = p->Pnt2d().XY();
349	return Standard_True;
350	}
351
352	Standard_Boolean MoniTool_CaseData::Reals
353	(const Standard_Integer nd,
354	Standard_Real& v1, Standard_Real& v2) const
355	{
356	Handle(Geom2d_CartesianPoint) p = Handle(Geom2d_CartesianPoint)::DownCast(Data(nd));
357	if (p.IsNull()) return Standard_False;
358	v1 = p->X(); v2 = p->Y();
359	return Standard_True;
360	}
361
362
363	Standard_Boolean MoniTool_CaseData::Real
364	(const Standard_Integer nd,
365	Standard_Real& val) const
366	{
367	Handle(Geom2d_CartesianPoint) p = Handle(Geom2d_CartesianPoint)::DownCast(Data(nd));
368	if (p.IsNull()) return Standard_False;
369	val = p->X();
370	return Standard_True;
371	}
372
373	Standard_Boolean MoniTool_CaseData::Text
374	(const Standard_Integer nd,
375	Standard_CString& text) const
376	{
377	Handle(TCollection_HAsciiString) t = Handle(TCollection_HAsciiString)::DownCast(Data(nd));
378	if (t.IsNull()) return Standard_False;
379	text = t->ToCString();
380	return Standard_True;
381	}
382
383	Standard_Boolean MoniTool_CaseData::Integer
384	(const Standard_Integer nd,
385	Standard_Integer& val) const
386	{
387	Handle(Geom2d_CartesianPoint) p = Handle(Geom2d_CartesianPoint)::DownCast(Data(nd));
388	// if (p.IsNull()) return Standard_False;
389	if (thekind(nd) != 11) return Standard_False;
390	Standard_Real rval = p->X();
391	val = (Standard_Integer)rval;
392	return Standard_True;
393	}
394
395
396	// #### MESSAGES ET DEFINITIONS ####
397
398	Message_Msg MoniTool_CaseData::Msg () const
399	{
400	Standard_CString defm = DefMsg (thecase.ToCString());
401
402	// A REPRENDRE COMPLETEMENT ! Il faut analyser defm = mescode + variables
403	Message_Msg mess;
404	mess.Set (defm);
405
406	return mess;
407	}
408
409
410	void MoniTool_CaseData::SetDefWarning (const Standard_CString acode)
411	{ defchecks()->SetItem (acode,1); }
412
413	void MoniTool_CaseData::SetDefFail (const Standard_CString acode)
414	{ defchecks()->SetItem (acode,2); }
415
416	Standard_Integer MoniTool_CaseData::DefCheck (const Standard_CString acode)
417	{
418	Standard_Integer val;
419	if (!defchecks()->GetItem (acode,val)) val = 0;
420	return val;
421	}
422
423
424	void MoniTool_CaseData::SetDefMsg
425	(const Standard_CString casecode, const Standard_CString mesdef)
426	{
427	Handle(TCollection_HAsciiString) str = new TCollection_HAsciiString (mesdef);
428	defmess()->SetItem (casecode,str);
429	}
430
431	Standard_CString MoniTool_CaseData::DefMsg (const Standard_CString casecode)
432	{
433	//Standard_CString mesd;
434	Handle(TCollection_HAsciiString) str;
435	if (!defmess()->GetItem (casecode,str)) return "";
436	if (str.IsNull()) return "";
437	return str->ToCString();
438	}