bool MyPin::CheckLive(IPin* pPin)
{
assert(pPin);
bool live = false;
IAMGraphStreamsPtr graphStreams;
IAMPushSourcePtr pushSource;
if (SUCCEEDED(m_pFilter->GetFilterGraph()->QueryInterface(IID_PPV_ARGS(&graphStreams))) &&
SUCCEEDED(graphStreams->FindUpstreamInterface(pPin, IID_PPV_ARGS(&pushSource), AM_INTF_SEARCH_OUTPUT_PIN)))
{
live = true;
ULONG flags;
if (SUCCEEDED(pushSource->GetPushSourceFlags(&flags)))
{
if (flags & AM_PUSHSOURCECAPS_INTERNAL_RM)
DebugOut(ClassName(this), "upstream live pin has AM_PUSHSOURCECAPS_INTERNAL_RM flag");
if (flags & AM_PUSHSOURCECAPS_NOT_LIVE)
{
DebugOut(ClassName(this), "upstream live pin has AM_PUSHSOURCECAPS_NOT_LIVE flag");
live = false;
}
if (flags & AM_PUSHSOURCECAPS_PRIVATE_CLOCK)
DebugOut(ClassName(this), "upstream live pin has AM_PUSHSOURCECAPS_PRIVATE_CLOCK flag");
if (flags & AM_PUSHSOURCEREQS_USE_STREAM_CLOCK)
DebugOut(ClassName(this), "upstream live pin has AM_PUSHSOURCEREQS_USE_STREAM_CLOCK flag");
if (!flags)
DebugOut(ClassName(this), "upstream live pin has no flags");
}
}
return live;
}
Res InstDescribe(Inst inst, mps_lib_FILE *stream, Count depth)
{
InstClass klass;
if (!TESTC(Inst, inst))
return ResPARAM;
if (stream == NULL)
return ResPARAM;
klass = ClassOfPoly(Inst, inst);
return WriteF(stream, depth,
"$S $P\n", (WriteFS)ClassName(klass), inst,
NULL);
}
void EnumGenerator::GenerateDescriptorInitializer(
io::Printer* printer, int index) {
map<string, string> vars;
vars["classname"] = classname_;
vars["index"] = SimpleItoa(index);
if (descriptor_->containing_type() == NULL) {
printer->Print(vars,
"$classname$_descriptor_ = file->enum_type($index$);\n");
} else {
vars["parent"] = ClassName(descriptor_->containing_type(), false);
printer->Print(vars,
"$classname$_descriptor_ = $parent$_descriptor_->enum_type($index$);\n");
}
}
JSFunctionSpec *
JSSphere::Functions() {
AC_DEBUG << "Registering class '"<<ClassName()<<"'"<<endl;
static JSFunctionSpec myFunctions[] = {
/* name native nargs */
{"makeEmpty", makeEmpty, 0},
{"extendBy", extendBy, 1},
{"contains", contains, 1},
{"envelopes", envelopes, 1},
{"touches", touches, 1},
{"intersects", intersects, 1},
{"toString", toString, 0},
{0}
};
return myFunctions;
}
shared_ptr<MethodBody> ContextBuilder::buildMethod(
const shared_ptr<MethodDeclaration> &method) {
std::map< PropertyName, ClassName > args;
for (auto elem : method->getArgs()) {
args[PropertyName(elem.first)] = ClassName(elem.second);
}
MethodName methodName(method->getName());
auto term = buildMethodBody(method->getBodyTerm());
return std::make_shared< MethodBody >(
methodName,
term,
args
);
}
void DwString::PrintDebugInfo(std::ostream& aStrm) const
{
aStrm <<
"----------------- Debug info for DwString class ----------------\n";
aStrm << "Id: " << ClassName() << ", " << ObjectId() << "\n";
aStrm << "Rep: " << (void*) mRep << "\n";
aStrm << "Buffer: " << (void*) mRep->mBuffer << "\n";
aStrm << "Buffer size: " << mRep->mSize << "\n";
aStrm << "Start: " << mStart << "\n";
aStrm << "Length: " << mLength << "\n";
aStrm << "Contents: ";
for (size_t i=0; i < mLength && i < 64; ++i) {
aStrm << mRep->mBuffer[mStart+i];
}
aStrm << std::endl;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void YSChoiAbaqusReader::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
VoxelDataContainer* m = getVoxelDataContainer();
if (getInputFile().empty() == true)
{
ss << ClassName() << " needs the Input File Set and it was not.";
setErrorCondition(-387);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
else if (MXAFileInfo::exists(getInputFile()) == false)
{
ss << "The input file does not exist.";
setErrorCondition(-388);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
else
{
const unsigned int size(1024);
char buf[size];
// Read header from data file to figure out how many points there are
std::ifstream in(getInputFile().c_str());
std::string word;
bool headerdone = false;
int xpoints, ypoints, zpoints;
float resx, resy, resz;
while (headerdone == false)
{
in.getline(buf, size);
std::string line = buf;
in >> word;
if (DIMS == word)
{
in >> xpoints >> ypoints >> zpoints;
size_t dims[3] = {xpoints, ypoints, zpoints};
m->setDimensions(dims);
m->setOrigin(0,0,0);
}
if (RES == word)
{
in >> resx >> resy >> resz;
float res[3] = {resx, resy, resz};
m->setResolution(res);
}
}
void TDSPMultiEcho::Print() {
cout << "OBJ: " << ClassName() << " " << "name=" << GetName();
cout << " title=" << GetTitle() << endl;
cout << " Number of Echos = " << fNumEchos << endl;
cout << " Symbol Frequency = " << GetSymbolRateMHz() << " MHz" << endl;
cout << " Sample Frequency = " << GetSymbolRateMHz()*fOverSampling << " MHz" << endl;
cout << " Oversampling = " << fOverSampling << endl;
cout << " Max Doppler = " << fMaxDoppler << "(v=" << GetSpeedKMH() << " kmh at f0=";
cout << GetCarrierFrequencyMHz() << " MHz)" << endl;
cout << " Symbol period = " << 1./GetSymbolRateMHz() << " µs" << endl;
cout << " Sample period = " << 1./GetSymbolRateMHz()/fOverSampling << " µs" << endl;
cout << " No. of time slices = " << fNumSlices << endl;
cout << " Echo-pdf's = ..." << endl;
ls();
if (!fRandomPhases)
cout<< " Ignoring Phases of the Echos..." << endl;
}
Bool GWinControl::Init(GWinControl* pOwner, u32 Flags, u32 ControlID, char* WindowName)
{
// check we havent already created a contorl
if ( m_Hwnd != NULL )
{
GDebug_Break("Control already created\n");
return FALSE;
}
// create control
Flags |= AdditionalStyleFlags();
m_StyleFlags = Flags;
// HMENU hMenu = (HMENU)ControlID;
HMENU hMenu = (HMENU)NULL;
HINSTANCE hInstance = GApp::g_HInstance;
HWND OwnerHwnd = pOwner ? pOwner->m_Hwnd : m_OwnerHwnd;
// reset handle
m_Hwnd = NULL;
m_ControlID = ControlID;
m_pOwnerControl = pOwner;
// get resulting hwnd, m_Hwnd is set from the WM_CREATE callback
HWND ResultHwnd = CreateWindowEx( StyleExFlags(), ClassName(), WindowName, StyleFlags(), m_ClientPos.x, m_ClientPos.y, m_ClientSize.x, m_ClientSize.y, OwnerHwnd, hMenu, hInstance, (void*)this );
// if control doesnt get a WM_CREATE (if its a standard windows control) call it
if ( ResultHwnd != NULL && m_Hwnd == NULL )
{
OnWindowCreate( this, ResultHwnd );
}
// failed
if ( m_Hwnd == NULL || ResultHwnd == NULL || m_Hwnd != ResultHwnd )
{
GDebug::CheckWin32Error();
return FALSE;
}
// control has been created
OnCreate();
return TRUE;
}
ATOM Window::Register(HINSTANCE hinst)
{
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)Window::s_WinProc;
wcex.cbClsExtra = GetClassExtra();
wcex.cbWndExtra = GetWinExtra();
wcex.hInstance = hinst;
wcex.hIcon = GetIcon();
wcex.hCursor = GetCursor();
wcex.hbrBackground = GetBrush();
wcex.lpszMenuName = GetMenu();
wcex.lpszClassName = ClassName();
wcex.hIconSm = GetSmallIcon();
return RegisterClassEx(&wcex);
}
void CEmbeddedObject::PrintObject(CChars* psz, BOOL bEmbedded)
{
int iDistToRoot;
int iDistToStack;
psz->Append(PointerToString(this));
psz->Append(" [");
iDistToRoot = GetDistToRoot();
if (iDistToRoot >= 0 && iDistToRoot <= 9)
{
psz->Append(" ");
}
psz->Append(iDistToRoot);
iDistToStack = GetDistToStack();
if (iDistToStack != UNKNOWN_DIST_TO_STACK)
{
psz->Append(",");
psz->Append(iDistToStack);
}
psz->Append("]:");
if (bEmbedded)
{
psz->Append("(");
}
psz->Append(ClassName());
psz->Append("(");
psz->Append(ClassSize());
psz->Append(") Index:");
psz->Append(GetOI());
if (IsNamed())
{
psz->Append(" Name:");
psz->Append(GetName());
}
psz->Append(" Froms:");
psz->Append(CEmbeddedObject::NumHeapFroms());
psz->Append(",");
psz->Append(CEmbeddedObject::NumStackFroms());
if (bEmbedded)
{
psz->Append(")");
}
}
void AudioDevicePush::Reset()
{
DebugOut(ClassName(this), "reset");
if (m_thread.joinable())
{
m_exit = true;
m_wake.Set();
m_thread.join();
m_exit = false;
}
m_backend->audioClient->Reset();
m_pushedFrames = 0;
m_silenceFrames = 0;
m_endOfStream = false;
m_endOfStreamPos = 0;
}
Int_t KVSpectroDetector::Compare(const TObject* obj) const{
//Compare two KVSpectroDetector objects from the Z coordinate of their
//first active volume in the Focal Plan reference frame. Returns 0 when Z
//is equal, -1 if this is smaller and +1 when bigger.
Double_t xyz[] = {0,0,0,0,0,0};
Bool_t ok = kTRUE;
ok &= ((KVSpectroDetector *)obj )->ActiveVolumeToFocal( xyz, xyz );
ok &= ((KVSpectroDetector *)this)->ActiveVolumeToFocal( xyz+3, xyz+3 );
if( !ok ){
Warning("Compare","Impossible to compare both %s objects %s and %s",ClassName(),GetName(), obj->GetName());
return 0;
}
Double_t Delta = xyz[5] - xyz[2];
if( Delta == 0 ) return 0;
if( Delta < 0 ) return -1;
return 1;
}
JSFunctionSpec *
cairo::JSSurface::Functions() {
IF_REG(cerr << "Registering class '"<<ClassName()<<"'"<<endl);
static JSFunctionSpec myFunctions[] = {
// name native nargs
{"toString", toString, 0},
{"flush", flush, 0},
{"getWidth", getWidth, 0},
{"getHeight", getHeight, 0},
{"writeToPNG", writeToPNG, 1},
// XXX hack to allow triggering texture upload -ingo
{"triggerUpload", triggerUpload, 0},
{0}
};
return myFunctions;
}
void KVINDRAOnlineDataAnalyser::preInitAnalysis()
{
// Before calling user's InitAnalysis we start the thread listening for messages on port 9091
// The TCP/IP port connected to the server is printed.
fStart.Set();
Info("InitAnalysis", "Started analysis on %s", fStart.AsString());
last_events = 0;
fEventsRefresh = 100;
// Test ports for availability
TestPorts(10000);
TString path("$(HOME)/.kvonlineanalysisrc");
gSystem->ExpandPathName(path);
TEnv env(path.Data());
env.SetValue(Form("%s.%s.Messages.port", ClassName(), gSystem->HostName()), port);
env.SaveLevel(kEnvLocal);
//
// fMessageThread = new TThread("AnalysisMess",(void(*)(void*))&ecouteSockets, (void*) this);
// Info("InitAnalysis","Started ecoutesocket on port %d", port);
// fMessageThread->Run();
}
static Variant HHVM_METHOD(EventHttpRequest, getEventBufferEvent) {
evhttp_connection_t *conn;
event_buffer_event_t *bevent;
EventHttpRequestResourceData *event_http_request_resource_data = FETCH_RESOURCE(this_, EventHttpRequestResourceData, s_event_http_request);
if((conn = evhttp_request_get_connection((evhttp_request_t *) event_http_request_resource_data->getInternalResourceData())) == NULL){
return Variant();
}
if((bevent = evhttp_connection_get_bufferevent(conn)) == NULL){
return Variant();
}
String ClassName("EventBufferEvent");
Object event_buffer_event = ObjectData::newInstance(Unit::lookupClass(ClassName.get()));
Resource resource;
resource = Resource(NEWOBJ(EventBufferEventResourceData(bevent, event_buffer_event.get())));
SET_RESOURCE(event_buffer_event, resource, s_event_bufferevent);
EventBufferEventResourceData *event_buffer_event_resource_data = FETCH_RESOURCE(event_buffer_event, EventBufferEventResourceData, s_event_bufferevent);
event_buffer_event_resource_data->isInternal = true;
return event_buffer_event;
}
Bool GWinControl::CreateClass()
{
WNDCLASS wc;
ZeroMemory(&wc,sizeof(wc));
wc.style = ClassStyle();
wc.lpfnWndProc = Win32CallBack;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = GApp::g_HInstance;
wc.hIcon = GetIconHandle();
wc.hCursor = NULL;//LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = GetBackgroundBrush();
wc.lpszMenuName = NULL;
wc.lpszClassName = ClassName();
if (!RegisterClass(&wc))
{
GDebug::CheckWin32Error();
return FALSE;
}
return TRUE;
}
UINT32 AudioDevicePush::PushSilenceToDevice(UINT32 frames)
{
// Get up-to-date information on the device buffer.
UINT32 bufferPadding;
ThrowIfFailed(m_backend->audioClient->GetCurrentPadding(&bufferPadding));
// Find out how many frames we can write this time.
const UINT32 doFrames = std::min(m_backend->deviceBufferSize - bufferPadding, frames);
if (doFrames == 0)
return 0;
// Write frames to the device buffer.
BYTE* deviceBuffer;
ThrowIfFailed(m_backend->audioRenderClient->GetBuffer(doFrames, &deviceBuffer));
ThrowIfFailed(m_backend->audioRenderClient->ReleaseBuffer(doFrames, AUDCLNT_BUFFERFLAGS_SILENT));
DebugOut(ClassName(this), "push", 1000. * doFrames / m_backend->waveFormat->nSamplesPerSec, "ms of silence");
m_pushedFrames += doFrames;
return doFrames;
}
//////////////////////////////////////////////////////////////////////////
//
// Description - Constructor
// Input - keep alive cnt
// keep alive interval
// backoff timer
//
// Output - None
//
///////////////////////////////////////////////////////////////////////////
CWatcherSession::CWatcherSession(int a_keepInterval, int a_keepCnt, int a_backoff,std::string a_serverAddress,
int a_serverPort, std::string a_resourceType,MrcpCallBackFunction a_callbackFunc)
:m_serverDown(false)
,m_watcherUpLoopExited(false)
,m_watcherDownLoopExited(false)
,m_exitUpLoop(false)
,m_exitDownLoop(false)
,m_keepAliveInterval(a_keepInterval)
,m_keepAliveCnt(a_keepCnt)
,m_connectBackoff(a_backoff)
,m_serverAddress(a_serverAddress)
,m_serverPort(a_serverPort)
,m_resourceType(a_resourceType)
,m_callbackFunc(a_callbackFunc)
{
int l_optval = 1;
ClassName("CWatcherSession");
CLogger::Instance()->Log(LOG_LEVEL_DEBUG,*this,"Entering");
CLogger::Instance()->Log(LOG_LEVEL_DEBUG,*this,"Interval", m_keepAliveInterval);
CLogger::Instance()->Log(LOG_LEVEL_DEBUG,*this,"count", m_keepAliveCnt);
CLogger::Instance()->Log(LOG_LEVEL_DEBUG,*this,"Backoff", m_connectBackoff);
}
JSObject *
JSSphere::initClass(JSContext *cx, JSObject *theGlobalObject) {
JSObject * myClass = Base::initClass(cx, theGlobalObject, ClassName(), Constructor, Properties(), Functions());
DOC_MODULE_CREATE("Math",JSSphere);
return myClass;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void YSChoiAbaqusReader::dataCheck()
{
DataArrayPath tempPath;
setErrorCondition(0);
DataContainer::Pointer m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
m->setGeometry(image);
QVector<size_t> tDims(3, 0);
AttributeMatrix::Pointer cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if(getErrorCondition() < 0 || NULL == cellAttrMat.get()) { return; }
tDims.resize(1);
tDims[0] = 0;
AttributeMatrix::Pointer cellFeatureAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellFeatureAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellFeature);
if(getErrorCondition() < 0 || NULL == cellFeatureAttrMat.get()) { return; }
AttributeMatrix::Pointer cellEnsembleAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellEnsembleAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellEnsemble);
if(getErrorCondition() < 0 || NULL == cellEnsembleAttrMat.get()) { return; }
QFileInfo fi(getInputFile());
if (getInputFile().isEmpty() == true)
{
QString ss = QObject::tr("%1 needs the Input File Set and it was not.").arg(ClassName());
setErrorCondition(-387);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
else if (fi.exists() == false)
{
QString ss = QObject::tr("The input file does not exist");
setErrorCondition(-388);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
else
{
bool ok = false;
//const unsigned int size(1024);
// Read header from data file to figure out how many points there are
QFile in(getInputFile());
if (!in.open(QIODevice::ReadOnly | QIODevice::Text))
{
QString msg = QObject::tr("Abaqus file could not be opened: %1").arg(getInputFile());
setErrorCondition(-100);
notifyErrorMessage(getHumanLabel(), "", getErrorCondition());
return;
}
QString word;
bool headerdone = false;
int xpoints, ypoints, zpoints;
float resx, resy, resz;
while (headerdone == false)
{
QByteArray buf = in.readLine();
if (buf.startsWith(DIMS))
{
QList<QByteArray> tokens = buf.split(' ');
xpoints = tokens[1].toInt(&ok, 10);
ypoints = tokens[2].toInt(&ok, 10);
zpoints = tokens[3].toInt(&ok, 10);
size_t dims[3] = { static_cast<size_t>(xpoints), static_cast<size_t>(ypoints), static_cast<size_t>(zpoints) };
m->getGeometryAs<ImageGeom>()->setDimensions(dims);
m->getGeometryAs<ImageGeom>()->setOrigin(0, 0, 0);
}
if (RES == word)
{
QList<QByteArray> tokens = buf.split(' ');
resx = tokens[1].toInt(&ok, 10);
resy = tokens[2].toInt(&ok, 10);
resz = tokens[3].toInt(&ok, 10);
float res[3] = {resx, resy, resz};
m->getGeometryAs<ImageGeom>()->setResolution(res);
}
}
}
QVector<size_t> dims(1, 3);
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getCellEulerAnglesArrayName() );
m_CellEulerAnglesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CellEulerAnglesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CellEulerAngles = m_CellEulerAnglesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 4;
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getQuatsArrayName() );
m_QuatsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_QuatsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_Quats = m_QuatsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellFeatureAttributeMatrixName(), getAvgQuatsArrayName() );
m_AvgQuatsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_AvgQuatsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_AvgQuats = m_AvgQuatsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 1;
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getCellPhasesArrayName() );
m_CellPhasesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 1, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CellPhasesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CellPhases = m_CellPhasesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellFeatureAttributeMatrixName(), getSurfaceFeaturesArrayName() );
m_SurfaceFeaturesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<bool>, AbstractFilter, bool>(this, tempPath, false, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceFeaturesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceFeatures = m_SurfaceFeaturesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getFeatureIdsArrayName() );
m_FeatureIdsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_FeatureIdsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_FeatureIds = m_FeatureIdsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
//typedef DataArray<unsigned int> XTalStructArrayType;
tempPath.update(getDataContainerName(), getCellEnsembleAttributeMatrixName(), getCrystalStructuresArrayName() );
m_CrystalStructuresPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<uint32_t>, AbstractFilter, uint32_t>(this, tempPath, Ebsd::CrystalStructure::Cubic_High, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CrystalStructuresPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CrystalStructures = m_CrystalStructuresPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
void hsBounds::prcWrite(pfPrcHelper* prc) {
prc->writeSimpleTag(ClassName());
IPrcWrite(prc);
prc->closeTag();
}
void VInvocation::CheckDecorateParams(VEmitContext& ec)
{
guard(VInvocation::CheckDecorateParams);
int max_params;
int num_needed_params = Func->NumParams;
if (Func->Flags & FUNC_VarArgs)
{
max_params = VMethod::MAX_PARAMS - 1;
}
else
{
max_params = Func->NumParams;
}
if (NumArgs > max_params)
{
ParseError(Loc, "Incorrect number of arguments, need %d, got %d.", max_params, NumArgs);
}
for (int i = 0; i < NumArgs; i++)
{
if (i >= num_needed_params)
{
continue;
}
if (!Args[i])
{
continue;
}
switch (Func->ParamTypes[i].Type)
{
case TYPE_Name:
if (Args[i]->IsDecorateSingleName())
{
VDecorateSingleName* E = (VDecorateSingleName*)Args[i];
Args[i] = new VNameLiteral(*E->Name, E->Loc);
delete E;
E = NULL;
}
else if (Args[i]->IsStrConst())
{
VStr Val = Args[i]->GetStrConst(ec.Package);
TLocation ALoc = Args[i]->Loc;
delete Args[i];
Args[i] = NULL;
Args[i] = new VNameLiteral(*Val, ALoc);
}
break;
case TYPE_String:
if (Args[i]->IsDecorateSingleName())
{
VDecorateSingleName* E = (VDecorateSingleName*)Args[i];
Args[i] = new VStringLiteral(ec.Package->FindString(*E->Name), E->Loc);
delete E;
E = NULL;
}
break;
case TYPE_Class:
if (Args[i]->IsDecorateSingleName())
{
VDecorateSingleName* E = (VDecorateSingleName*)Args[i];
Args[i] = new VStringLiteral(ec.Package->FindString(*E->Name), E->Loc);
delete E;
E = NULL;
}
if (Args[i]->IsStrConst())
{
VStr CName = Args[i]->GetStrConst(ec.Package);
TLocation ALoc = Args[i]->Loc;
VClass* Cls = VClass::FindClassNoCase(*CName);
if (!Cls)
{
ParseWarning(ALoc, "No such class %s", *CName);
delete Args[i];
Args[i] = NULL;
Args[i] = new VNoneLiteral(ALoc);
}
else if (Func->ParamTypes[i].Class &&
!Cls->IsChildOf(Func->ParamTypes[i].Class))
{
ParseWarning(ALoc, "Class %s is not a descendant of %s",
*CName, Func->ParamTypes[i].Class->GetName());
delete Args[i];
Args[i] = NULL;
Args[i] = new VNoneLiteral(ALoc);
}
else
{
delete Args[i];
Args[i] = NULL;
Args[i] = new VClassConstant(Cls, ALoc);
}
}
break;
case TYPE_State:
if (Args[i]->IsIntConst())
{
int Offs = Args[i]->GetIntConst();
TLocation ALoc = Args[i]->Loc;
if (Offs < 0)
{
ParseError(ALoc, "Negative state jumps are not allowed");
}
else if (Offs == 0)
{
// 0 means no state
delete Args[i];
Args[i] = NULL;
Args[i] = new VNoneLiteral(ALoc);
}
else
{
check(CallerState);
VState* S = CallerState->GetPlus(Offs, true);
if (!S)
{
ParseError(ALoc, "Bad state jump offset");
}
else
{
delete Args[i];
Args[i] = NULL;
Args[i] = new VStateConstant(S, ALoc);
}
}
}
else if (Args[i]->IsStrConst())
{
VStr Lbl = Args[i]->GetStrConst(ec.Package);
TLocation ALoc = Args[i]->Loc;
int DCol = Lbl.IndexOf("::");
if (DCol >= 0)
{
// Jump to a specific parent class state, resolve it and
// pass value directly.
VStr ClassName(Lbl, 0, DCol);
VClass* CheckClass;
if (ClassName.ICmp("Super"))
{
CheckClass = ec.SelfClass->ParentClass;
}
else
{
CheckClass = VClass::FindClassNoCase(*ClassName);
if (!CheckClass)
{
ParseError(ALoc, "No such class %s", *ClassName);
}
else if (!ec.SelfClass->IsChildOf(CheckClass))
{
ParseError(ALoc, "%s is not a subclass of %s",
ec.SelfClass->GetName(), CheckClass->GetName());
CheckClass = NULL;
}
}
if (CheckClass)
{
VStr LblName(Lbl, DCol + 2, Lbl.Length() - DCol - 2);
TArray<VName> Names;
VMemberBase::StaticSplitStateLabel(LblName, Names);
VStateLabel* StLbl = CheckClass->FindStateLabel(Names, true);
if (!StLbl)
{
ParseError(ALoc, "No such state %s", *Lbl);
}
else
{
delete Args[i];
Args[i] = NULL;
Args[i] = new VStateConstant(StLbl->State, ALoc);
}
}
}
else
{
// It's a virtual state jump
VExpression* TmpArgs[1];
TmpArgs[0] = Args[i];
Args[i] = new VInvocation(NULL,
ec.SelfClass->FindMethodChecked("FindJumpState"),
NULL, false, false, Args[i]->Loc, 1, TmpArgs);
}
}
break;
}
}
unguard;
}
void KVIonRangeTable::Print(Option_t*) const
{
printf("%s::%s\n%s\n", ClassName(), GetName(), GetTitle());
}
void DwMessageComponent::_PrintDebugInfo(std::ostream& aStrm) const
{
aStrm << "ObjectId: " << ObjectId() << '\n';
aStrm << "ClassId: ";
switch (ClassId()) {
case kCidError:
aStrm << "kCidError";
break;
case kCidUnknown:
aStrm << "kCidUnknown";
break;
case kCidAddress:
aStrm << "kCidAddress";
break;
case kCidAddressList:
aStrm << "kCidAddressList";
break;
case kCidBody:
aStrm << "kCidBody";
break;
case kCidBodyPart:
aStrm << "kCidBodyPart";
break;
case kCidDispositionType:
aStrm << "kCidDispositionType";
break;
case kCidMechanism:
aStrm << "kCidMechanism";
break;
case kCidMediaType:
aStrm << "kCidMediaType";
break;
case kCidParameter:
aStrm << "kCidParameter";
break;
case kCidDateTime:
aStrm << "kCidDateTime";
break;
case kCidEntity:
aStrm << "kCidEntity";
break;
case kCidField:
aStrm << "kCidField";
break;
case kCidFieldBody:
aStrm << "kCidFieldBody";
break;
case kCidGroup:
aStrm << "kCidGroup";
break;
case kCidHeaders:
aStrm << "kCidHeaders";
break;
case kCidMailbox:
aStrm << "kCidMailbox";
break;
case kCidMailboxList:
aStrm << "kCidMailboxList";
break;
case kCidMessage:
aStrm << "kCidMessage";
break;
case kCidMessageComponent:
aStrm << "kCidMessageComponent";
break;
case kCidMsgId:
aStrm << "kCidMsgId";
break;
case kCidText:
aStrm << "kCidText";
break;
}
aStrm << '\n';
aStrm << "ClassName: " << ClassName() << '\n';
aStrm << "String: " << mString << '\n';
aStrm << "IsModified: " << (IsModified() ? "True" : "False") << '\n';
aStrm << "Parent ObjectId: ";
if (mParent) {
aStrm << mParent->ObjectId() << '\n';
}
else {
aStrm << "(none)\n";
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VisualizeGBCDGMT::dataCheck()
{
setErrorCondition(0);
getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getGBCDArrayPath().getDataContainerName());
if (getOutputFile().isEmpty() == true)
{
QString ss = QObject::tr( "The output file must be set");
setErrorCondition(-1000);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
QFileInfo fi(getOutputFile());
QDir parentPath = fi.path();
if (parentPath.exists() == false && getInPreflight())
{
QString ss = QObject::tr( "The directory path for the output file does not exist. DREAM.3D will attempt to create this path during execution of the filter");
notifyWarningMessage(getHumanLabel(), ss, -1);
}
if (fi.suffix().compare("") == 0)
{
setOutputFile(getOutputFile().append(".dat"));
}
// Make sure the file name ends with _1 so the GMT scripts work correctly
QString fName = fi.baseName();
if (fName.endsWith("_1") == false)
{
fName = fName + "_1";
QString absPath = fi.absolutePath() + "/" + fName + ".dat";
setOutputFile(absPath);
}
QVector<size_t> cDims(1, 1);
m_CrystalStructuresPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<unsigned int>, AbstractFilter>(this, getCrystalStructuresArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if (NULL != m_CrystalStructuresPtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{
m_CrystalStructures = m_CrystalStructuresPtr.lock()->getPointer(0);
} /* Now assign the raw pointer to data from the DataArray<T> object */
IDataArray::Pointer tmpGBCDPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getGBCDArrayPath());
if(getErrorCondition() < 0) { return; }
if (NULL != tmpGBCDPtr.get())
{
QVector<size_t> cDims = tmpGBCDPtr->getComponentDimensions();
m_GBCDPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<double>, AbstractFilter>(this, getGBCDArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_GBCDPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_GBCD = m_GBCDPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
if (NULL != m_GBCDPtr.lock().get() && getPhaseOfInterest() >= m_GBCDPtr.lock()->getNumberOfTuples())
{
QString ss = QObject::tr("The phase index is larger than the number of Ensembles").arg(ClassName());
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
KVFAZIALNS2016::KVFAZIALNS2016()
: KVFAZIA()
{
// Default constructor
SetTitle(ClassName());
}
CSelectTeamWindow::~CSelectTeamWindow()
{
RemoveFromList(ClassName());
}
void AudioDevicePush::Stop()
{
DebugOut(ClassName(this), "stop");
m_backend->audioClient->Stop();
}
JSBool
JSSphere::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {
DOC_BEGIN("Constructs a sphere from center/radius, center/point on surface, from another sphere or an empty one.");
DOC_PARAM("a sphere", "", DOC_TYPE_SPHERE);
DOC_RESET;
DOC_PARAM("center", "", DOC_TYPE_POINT3F);
DOC_PARAM("radius", "", DOC_TYPE_FLOAT);
DOC_RESET;
DOC_PARAM("center", "", DOC_TYPE_POINT3F);
DOC_PARAM("point on surface", "", DOC_TYPE_POINT3F);
DOC_END;
IF_NOISY2(AC_TRACE << "Constructor argc =" << argc << endl);
if (JSA_GetClass(cx,obj) != Class()) {
JS_ReportError(cx,"Constructor for %s bad object; did you forget a 'new'?",ClassName());
return JS_FALSE;
}
JSSphere * myNewObject = 0;
JSSphere::NativeValuePtr myNewValue = JSSphere::NativeValuePtr(new dom::SimpleValue<asl::Sphere<Number> >(0));
asl::Sphere<Number> & myNewSphere = myNewValue->openWriteableValue(); // we close it only on success, otherwise we trash it anyway
if (argc == 0) {
// construct empty
myNewObject=new JSSphere(myNewValue);
} else {
if (argc == 2) {
JSObject * myObject = JSVector<asl::Point3<Number> >::Construct(cx, argv[0]);
if (!myObject) {
JS_ReportError(cx,"JSSphere::Constructor: first argument must be a normal vector of size 3",ClassName());
return JS_FALSE;
}
jsdouble myNumber;
if (JS_ValueToNumber(cx,argv[1],&myNumber) && !JSDOUBLE_IS_NaN(myNumber)) {
// construct from center/radius
myNewSphere = asl::Sphere<Number>(JSVector<asl::Point3<Number> >::getNativeRef(cx,myObject), Number(myNumber));
} else {
// construct from center/point on surface
JSObject * myObject2 = JSVector<asl::Point3<Number> >::Construct(cx, argv[1]);
if (!myObject2) {
JS_ReportError(cx,"JSSphere::Constructor: second argument must be a distance number or point on the plane of size 3",ClassName());
return JS_FALSE;
}
myNewSphere = asl::Sphere<Number>(JSVector<asl::Point3<Number> >::getNativeRef(cx,myObject),
JSVector<asl::Point3<Number> >::getNativeRef(cx,myObject2));
}
myNewObject=new JSSphere(myNewValue);
} else if (argc == 1) {
// construct from one Sphere
if (JSVAL_IS_VOID(argv[0])) {
JS_ReportError(cx,"JSSphere::Constructor: bad argument #1 (undefined)");
return JS_FALSE;
}
JSObject * myArgument;
if (!JS_ValueToObject(cx, argv[0], &myArgument)) {
JS_ReportError(cx,"JSSphere::Constructor: bad argument type, Sphere expected");
return JS_FALSE;
}
if (JSA_GetClass(cx,myArgument) == Class()) {
myNewSphere = getJSWrapper(cx, myArgument).getNative();
myNewObject=new JSSphere(myNewValue);
}
} else {
JS_ReportError(cx,"Constructor for %s: bad number of arguments: expected 0,1 or 2, got %d",ClassName(), argc);
return JS_FALSE;
}
}
if (myNewObject) {
JS_SetPrivate(cx,obj,myNewObject);
myNewValue->closeWriteableValue();
return JS_TRUE;
}
JS_ReportError(cx,"JSSphere::Constructor: bad parameters");
return JS_FALSE;
}
