/usr/include/opencascade/Dynamic.hxx is in libopencascade-foundation-dev 6.5.0.dfsg-2build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 | // This file is generated by WOK (CPPExt).
// Please do not edit this file; modify original file instead.
// The copyright and license terms as defined for the original file apply to
// this header file considered to be the "object code" form of the original source.
#ifndef _Dynamic_HeaderFile
#define _Dynamic_HeaderFile
#ifndef _Standard_HeaderFile
#include <Standard.hxx>
#endif
#ifndef _Standard_Macro_HeaderFile
#include <Standard_Macro.hxx>
#endif
#ifndef _Dynamic_ModeEnum_HeaderFile
#include <Dynamic_ModeEnum.hxx>
#endif
#ifndef _Standard_CString_HeaderFile
#include <Standard_CString.hxx>
#endif
class Dynamic_Node;
class Dynamic_Parameter;
class Dynamic_BooleanParameter;
class Dynamic_EnumerationParameter;
class Dynamic_IntegerParameter;
class Dynamic_RealParameter;
class Dynamic_StringParameter;
class Dynamic_ObjectParameter;
class Dynamic_InstanceParameter;
class Dynamic_ParameterNode;
class Dynamic_Variable;
class Dynamic_VariableGroup;
class Dynamic_AbstractVariableInstance;
class Dynamic_VariableInstance;
class Dynamic_CompositVariableInstance;
class Dynamic_VariableNode;
class Dynamic_Method;
class Dynamic_MethodDefinition;
class Dynamic_CompiledMethod;
class Dynamic_InterpretedMethod;
class Dynamic_CompositMethod;
class Dynamic_MethodInstance;
class Dynamic_MethodDefinitionsDictionary;
class Dynamic_SeqOfMethods;
class Dynamic_SequenceOfMethods;
class Dynamic_SeqOfMethodDefinitions;
class Dynamic_SequenceOfMethodDefinitions;
class Dynamic_DynamicClass;
class Dynamic_DynamicDerivedClass;
class Dynamic_SeqOfClasses;
class Dynamic_SequenceOfClasses;
class Dynamic_DynamicInstance;
class Dynamic_FuzzyClass;
class Dynamic_FuzzyDefinition;
class Dynamic_SeqOfFuzzyDefinitions;
class Dynamic_SequenceOfFuzzyDefinitions;
class Dynamic_FuzzyDefinitionsDictionary;
class Dynamic_FuzzyInstance;
class Dynamic_SequenceNodeOfSeqOfMethods;
class Dynamic_SequenceNodeOfSeqOfMethodDefinitions;
class Dynamic_SequenceNodeOfSeqOfClasses;
class Dynamic_SequenceNodeOfSeqOfFuzzyDefinitions;
//! This package propose a set of abstract persistent <br>
//! classes. These classes may be sort in three main <br>
//! groups, which are : <br>
//! <br>
//! - fuzzy classes <br>
//! - methods <br>
//! - dynamic classes <br>
//! <br>
//! And in two complementary groups used by the <br>
//! previously described family, which are : <br>
//! <br>
//! - parameter classes <br>
//! - variable classes <br>
//! <br>
//! All the main classes are manipulated through two <br>
//! steps which are : <br>
//! <br>
//! - the definition which gives the signature of the <br>
//! object <br>
//! - the instanciation which always references a <br>
//! definition <br>
//! <br>
//! This separation has been created to clearly <br>
//! separate the definition of an object, a method or <br>
//! a class which is the description and the instance <br>
//! which is the utilisation with a particular set of <br>
//! values. In this case for few instanciations of <br>
//! the same object, the definition can be unique. <br>
//! <br>
//! Each family address a particular problem. <br>
//! <br>
//! Dynamic class <br>
//! ------------- <br>
//! <br>
//! This family of classes offers the possibility to <br>
//! define and to manipulate dynamically objets with <br>
//! the same specifications as C++ objects. <br>
//! Dynamically means without CDL description and <br>
//! without compilation and link if all the methods <br>
//! attached are interpreted methods. <br>
//! <br>
//! The first thing to do is to define the signature <br>
//! of the class, in terms of fields and methods. <br>
//! <br>
//! You can also derive a class from others, add <br>
//! fields, and add or redefine methods. <br>
//! <br>
//! Then instances of the class can be created and <br>
//! values can be assigned to the fields. <br>
//! <br>
//! It is then possible to execute methods attached to <br>
//! the definition of the class. These methods may set <br>
//! computed values to other fields, or simply return <br>
//! them. <br>
//! <br>
//! A method can be compiled or interpreted. <br>
//! <br>
//! Fuzzy class <br>
//! ----------- <br>
//! <br>
//! A fuzzy class is a degeneration of a dynamic <br>
//! class. Only the fields are specified. These <br>
//! classes are useful to describe objects with <br>
//! various definitions, and with the number and the <br>
//! nature of fields depending of the definition. <br>
//! <br>
//! The definitions of the lights for Photo Realistic <br>
//! Renderer is an illutration of the use of the fuzzy <br>
//! classes. <br>
//! <br>
//! These lights have the same definitions in terms of <br>
//! parameters as the lights used in the LightWorks <br>
//! module. <br>
//! <br>
//! For each type of light an exhaustive set of <br>
//! parameters is described, and each parameter is <br>
//! defined by its name, its type and, if necessary, <br>
//! its default value as follows : <br>
//! <br>
//! ambient <br>
//! "intensity" Standard_Real 1.0 <br>
//! "colour" Materials_PColor 1.0 1.0 1.0 <br>
//! <br>
//! distant <br>
//! "intensity" Standard_Real 1.0 <br>
//! "colour" Materials_PColor 1.0 1.0 1.0 <br>
//! "location" PGeom_CartesianPoint 0.0 0.0 1.0 <br>
//! "to" PGeom_CartesianPoint 0.0 0.0 0.0 <br>
//! "shadows" Standard_Boolean Standard_False <br>
//! "shadow resolution" Standard_Integer 256 <br>
//! "shadow quality" Standard_Integer 4 <br>
//! "shadow softness" Standard_Real 1.0 <br>
//! <br>
//! eye <br>
//! "intensity" Standard_Real 1.0 <br>
//! "colour" Materials_PColor 1.0 1.0 1.0 <br>
//! <br>
//! point <br>
//! "intensity" Standard_Real 1.0 <br>
//! "colour" Materials_PColor 1.0 1.0 1.0 <br>
//! "location" PGeom_CartesianPoint 0.0 0.0 0.0 <br>
//! "fall off" LightWorks_LiFallOffType LI_FALL_OFF_CONSTANT <br>
//! "shadows" Standard_Boolean Standard_False <br>
//! "shadow resolution" Standard_Integer 256 <br>
//! "shadow quality" Standard_Integer 4 <br>
//! "shadow softness" Standard_Real 1.0 <br>
//! <br>
//! spot <br>
//! "intensity" Standard_Real 1.0 <br>
//! "colour" Materials_PColor 1.0 1.0 1.0 <br>
//! "location" PGeom_CartesianPoint 0.0 0.0 1.0 <br>
//! "to" PGeom_CartesianPoint 0.0 0.0 0.0 <br>
//! "fall off" LightWorks_LiFallOffType LI_FALL_OFF_CONSTANT <br>
//! "cone angle" Standard_Real 60.0 <br>
//! "cone delta angle" Standard_Real 5.0 <br>
//! "beam distribution" Standard_Real 2.0 <br>
//! "shadows" Standard_Boolean Standard_False <br>
//! "shadow resolution" Standard_Integer 256 <br>
//! "shadow quality" Standard_Integer 4 <br>
//! "shadow softness" Standard_Real 1.0 <br>
//! <br>
//! All these definitions are described in a file <br>
//! which is read at the first creation of a light <br>
//! instance to be put in a dictionary. <br>
//! <br>
//! At the creation of an instance, just a reference <br>
//! on the definition is set. All the parameter values <br>
//! are read in the definition. If now a value of one <br>
//! parameter is changed, the modified parameter is <br>
//! added to the instance. So only the modified <br>
//! parameters are directely attached to the instance. <br>
//! This behaviour allows the use of an instance as <br>
//! definition, and can be useful to create catalogs <br>
//! of standards which can be directly questioned in <br>
//! the database. <br>
//! <br>
//! The use of fuzzy classes needs four prerequisites <br>
//! which are : <br>
//! <br>
//! - The creation of a file with the exhaustive <br>
//! description of all the possible types taken by an <br>
//! object and for each type the complete set of <br>
//! parameters in terms of name, type, and, if <br>
//! necessary, default value. <br>
//! <br>
//! - The inheritance from the class <br>
//! FuzzyDefinitionsDictionary and, if necessary, the <br>
//! redefinition of the Switch method for the non- <br>
//! standard type of parameters described in the file. <br>
//! <br>
//! - The following method : <br>
//! <br>
//! void DictionaryOfDefinitions(Handle(MyPackage_MyDictionary)&); <br>
//! <br>
//! must be writen in the file MyPackage.cxx, because <br>
//! this method is automatically called by the <br>
//! constructor of FuzzyInstance. This method tests if <br>
//! the dictionary has been created yet. If it is <br>
//! true the method returns a reference to it, <br>
//! otherwise the method creates the dictionary before <br>
//! returning the reference. <br>
//! <br>
//! - The instanciation of the FuzzyInstance class <br>
//! with the pre-defined dictionary. <br>
//! <br>
//! Method class <br>
//! ------------ <br>
//! <br>
//! The behaviour of these classes are similar to <br>
//! fuzzy classes. Only the semantic is different. <br>
//! These classes are for memorized actions or <br>
//! constraints, e.g. they are useful to memorized <br>
//! persistently the working system of Imagine <br>
//! Conception. <br>
class Dynamic {
public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
Standard_EXPORT static Dynamic_ModeEnum Mode(const Standard_CString amode) ;
protected:
private:
friend class Dynamic_Node;
friend class Dynamic_Parameter;
friend class Dynamic_BooleanParameter;
friend class Dynamic_EnumerationParameter;
friend class Dynamic_IntegerParameter;
friend class Dynamic_RealParameter;
friend class Dynamic_StringParameter;
friend class Dynamic_ObjectParameter;
friend class Dynamic_InstanceParameter;
friend class Dynamic_ParameterNode;
friend class Dynamic_Variable;
friend class Dynamic_VariableGroup;
friend class Dynamic_AbstractVariableInstance;
friend class Dynamic_VariableInstance;
friend class Dynamic_CompositVariableInstance;
friend class Dynamic_VariableNode;
friend class Dynamic_Method;
friend class Dynamic_MethodDefinition;
friend class Dynamic_CompiledMethod;
friend class Dynamic_InterpretedMethod;
friend class Dynamic_CompositMethod;
friend class Dynamic_MethodInstance;
friend class Dynamic_MethodDefinitionsDictionary;
friend class Dynamic_SeqOfMethods;
friend class Dynamic_SequenceOfMethods;
friend class Dynamic_SeqOfMethodDefinitions;
friend class Dynamic_SequenceOfMethodDefinitions;
friend class Dynamic_DynamicClass;
friend class Dynamic_DynamicDerivedClass;
friend class Dynamic_SeqOfClasses;
friend class Dynamic_SequenceOfClasses;
friend class Dynamic_DynamicInstance;
friend class Dynamic_FuzzyClass;
friend class Dynamic_FuzzyDefinition;
friend class Dynamic_SeqOfFuzzyDefinitions;
friend class Dynamic_SequenceOfFuzzyDefinitions;
friend class Dynamic_FuzzyDefinitionsDictionary;
friend class Dynamic_FuzzyInstance;
friend class Dynamic_SequenceNodeOfSeqOfMethods;
friend class Dynamic_SequenceNodeOfSeqOfMethodDefinitions;
friend class Dynamic_SequenceNodeOfSeqOfClasses;
friend class Dynamic_SequenceNodeOfSeqOfFuzzyDefinitions;
};
// other Inline functions and methods (like "C++: function call" methods)
#endif
|