Field::Field(const TCHAR* Name, const TCHAR* Value, int _config, const bool duplicateValue):
lazy(false)
{
CND_PRECONDITION(Name != NULL, "Name cannot be NULL");
CND_PRECONDITION(Value != NULL, "value cannot be NULL");
CND_PRECONDITION(_tcslen(Value)>0 && _tcslen(Name)>0, "name and value cannot both be empty");
/*
if (_config & INDEX_NO && _config & STORE_NO)
_CLTHROWA(CL_ERR_IllegalArgument,"it doesn't make sense to have a field that is neither indexed nor stored");
if (_config & INDEX_NO && _config & TERMVECTOR_YES)
_CLTHROWA(CL_ERR_IllegalArgument,"cannot store term vector information for a field that is not indexed");
*/
_name = CLStringIntern::intern( Name );
if (duplicateValue)
fieldsData = stringDuplicate( Value );
else
fieldsData = (void*)Value;
valueType = VALUE_STRING;
boost=1.0f;
//config = INDEX_TOKENIZED; // default Field is tokenized and indexed
setConfig(_config);
}
/*--------------------------------------------------------------------------*/
void engine::start ( int argc , char **argv,bool sg){
int P,p,q;
config.getCmdLine(argc,argv);
P =config.P;
p =config.p;
q =config.q;
time_out = config.to;
printf("Engine start, pure-mpi=%d\n",config.pure_mpi);
ProcessGrid *_PG = new ProcessGrid(P,p,q);
ProcessGrid &PG=*_PG;
DataHostPolicy *hpData = new DataHostPolicy (DataHostPolicy::BLOCK_CYCLIC , PG );
TaskHostPolicy *hpTask = new TaskHostPolicy (TaskHostPolicy::WRITE_DATA_OWNER , PG );
ContextHostPolicy *hpContext = new ContextHostPolicy (ContextHostPolicy::ALL_ENTER , PG );
TaskReadPolicy *hpTaskRead= new TaskReadPolicy (TaskReadPolicy::ALL_READ_ALL , PG );
TaskAddPolicy *hpTaskAdd = new TaskAddPolicy (TaskAddPolicy::WRITE_DATA_OWNER , PG );
glbCtx.setPolicies(hpData,hpTask,hpContext,hpTaskRead,hpTaskAdd);
glbCtx.setConfiguration(&config);
if ( config.pure_mpi )
sg = true;
else
sg= false;
setConfig(&config,sg);
doProcess();
}
bool EglHwcomposerBackend::initBufferConfigs()
{
const EGLint config_attribs[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE,
};
EGLint count;
EGLConfig configs[1024];
if (eglChooseConfig(eglDisplay(), config_attribs, configs, 1, &count) == EGL_FALSE) {
qCCritical(KWIN_HWCOMPOSER) << "choose config failed";
return false;
}
if (count != 1) {
qCCritical(KWIN_HWCOMPOSER) << "choose config did not return a config" << count;
return false;
}
setConfig(configs[0]);
return true;
}
void ConfigSubscriptions::buttonClicked (Button* buttonThatWasClicked)
{
//[UserbuttonClicked_Pre]
//[/UserbuttonClicked_Pre]
if (buttonThatWasClicked == subscribeButton)
{
//[UserButtonCode_subscribeButton] -- add your button handler code here..
//[/UserButtonCode_subscribeButton]
}
else if (buttonThatWasClicked == ignoreButton)
{
//[UserButtonCode_ignoreButton] -- add your button handler code here..
//[/UserButtonCode_ignoreButton]
}
//[UserbuttonClicked_Post]
bool should_subscribe = this->subscribeButton->getToggleState() ;
bool should_ignore = this->ignoreButton->getToggleState() ;
int subscribe_mode = (should_ignore) ? NJClient::SUBSCRIBE_DENY :
(should_subscribe)? NJClient::SUBSCRIBE_ALL :
NJClient::SUBSCRIBE_NONE ;
setConfig(CONFIG::SUBSCRIBE_MODE_KEY , var(subscribe_mode)) ;
//[/UserbuttonClicked_Post]
}
void CBankInstanceConstructor::configureObject(CGObjectInstance * object, CRandomGenerator & rng) const
{
//logGlobal->debugStream() << "Seed used to configure bank is " << rng.nextInt();
auto bank = dynamic_cast<CBank*>(object);
bank->resetDuration = bankResetDuration;
si32 totalChance = 0;
for (auto & node : levels)
totalChance += node["chance"].Float();
assert(totalChance != 0);
si32 selectedChance = rng.nextInt(totalChance - 1);
//logGlobal->debugStream() << "Selected chance for bank config is " << selectedChance;
for (auto & node : levels)
{
if (selectedChance < node["chance"].Float())
{
bank->setConfig(generateConfig(node, rng));
}
else
{
selectedChance -= node["chance"].Float();
}
}
}
MachineConfigObject::MachineConfigObject(QObject *parent, MachineConfig *config)
: QObject(parent)
, myConfig(0)
{
setConfig(config);
connect(config, SIGNAL(optionChanged(QString, QString, QString, QVariant)),this,SLOT(configChanged(QString, QString, QString, QVariant)));
}
//__________________________________________________________________________
void Speller::Aspell::Suggest::init(const std::string& lang,
const std::string& jargon,
const std::string& encoding)
throw( std::invalid_argument, std::runtime_error )
{
// Save aspell configuration values
flang = lang;
fjargon = jargon;
fencoding = encoding;
fconfig = new_aspell_config();
try
{
setConfig();
}
catch( const std::invalid_argument& err )
{
throw err;
}
AspellCanHaveError* ret = new_aspell_speller( fconfig );
delete_aspell_config( fconfig );
if( aspell_error_number( ret ) != 0 )
{
delete_aspell_can_have_error( ret );
throw std::runtime_error( "(Aspell::Speller::Suggest::init"
"): Error in creating speller." );
}
else
{
fspeller = to_aspell_speller( ret );
fconfig = aspell_speller_config( fspeller );
}
}
//! Initialize resources.
void
onResourceInitialization(void)
{
if (!getConstantParameters())
throw RestartNeeded(DTR("failed to get constant parameters"), c_restart_delay);
setConfig();
std::map<std::string, LED*>::iterator itr = m_led_by_name.begin();
for (unsigned i = 0; i < c_led_count; ++i)
setBrightness(itr->second, 0);
if (!m_args.led_patterns.empty())
{
uint8_t count = m_args.led_patterns.size();
UCTK::Frame frame;
frame.setId(PKT_ID_LED_PATTERN);
frame.setPayloadSize(1 + (count * 2));
frame.set(count, 0);
for (size_t i = 0; i < count; ++i)
frame.set<uint16_t>(m_args.led_patterns[i], 1 + i * 2);
if (!m_ctl->sendFrame(frame))
throw RestartNeeded(DTR("failed to set LED patterns"), c_restart_delay);
}
m_wdog.reset();
setEntityState(IMC::EntityState::ESTA_NORMAL, Status::CODE_ACTIVE);
}
/******************************************************************************
Configures the device by setting it into the configured state.
Parameters:
cfgnum - configuration number to set
******************************************************************************/
static void runtimeSetConfiguration(uint8_t cfgnum)
{
// Set & save the desired configuration
setConfig(cfgnum);
// Acknowledge the request
txZLP();
}
Field::Field(const TCHAR* Name, Reader* reader, bool store, bool index, bool token, const bool storeTermVector)
{
//Func - Constructor
//Pre - Name != NULL and contains the name of the field
// reader != NULL and contains a Reader
// store indicates if the field must be stored
// index indicates if the field must be indexed
// token indicates if the field must be tokenized
//Post - The instance has been created
CND_PRECONDITION(Name != NULL, "Name is NULL");
CND_PRECONDITION(reader != NULL, "reader is NULL");
_name = LStringIntern::intern( Name CL_FILELINE);
_stringValue = NULL;
_readerValue = reader;
_streamValue = NULL;
boost=1.0f;
omitNorms = false;
int cfg = 0;
if ( store )
cfg |= STORE_YES;
if ( index && token )
cfg |= INDEX_TOKENIZED;
else if ( index && !token )
cfg |= INDEX_UNTOKENIZED;
if ( storeTermVector )
_CLTHROWA(CL_ERR_IllegalArgument,"Stored term vector is deprecated with using this constructor");
setConfig(cfg);
}
RabbitMQService::RabbitMQService (Glib::KeyFile &confFile) : Service (confFile)
{
sigset_t mask;
std::string address;
int port;
try {
address = confFile.get_string (RABBITMQ_GROUP, RABBITMQ_SERVER_ADDRESS);
} catch (const Glib::KeyFileError &err) {
GST_WARNING ("Setting default address %s to media server",
RABBITMQ_SERVER_ADDRESS_DEFAULT);
address = RABBITMQ_SERVER_ADDRESS_DEFAULT;
}
try {
port = confFile.get_integer (RABBITMQ_GROUP, RABBITMQ_SERVER_PORT);
check_port (port);
} catch (const Glib::KeyFileError &err) {
GST_WARNING ("Setting default port %d to media server",
RABBITMQ_SERVER_PORT_DEFAULT);
port = RABBITMQ_SERVER_PORT_DEFAULT;
}
this->address = address;
this->port = port;
setConfig (address, port);
this->confFile.load_from_data (confFile.to_data() );
sigemptyset (&mask);
sigaddset (&mask, SIGCHLD);
signalHandler = std::shared_ptr <SignalHandler> (new SignalHandler (mask,
std::bind (&RabbitMQService::childSignal, this, std::placeholders::_1) ) );
}
void Musec::loadLanguage(const QString& lang)
{
qApp->removeTranslator(fTranslator);
fTranslator->load(QLocale(lang), "musec", "_", ":/locales");
setConfig("lang", lang);
qApp->installTranslator(fTranslator);
}
MockReplicaSet::MockReplicaSet(const string& setName, size_t nodes):
_setName(setName) {
ReplConfigMap replConfig;
for (size_t n = 0; n < nodes; n++) {
std::stringstream str;
str << "$" << setName << n << ":27017";
const string hostName(str.str());
if (n == 0) {
_primaryHost = hostName;
}
MockRemoteDBServer* mockServer = new MockRemoteDBServer(hostName);
_nodeMap[hostName] = mockServer;
MockConnRegistry::get()->addServer(mockServer);
ReplSetConfig::MemberCfg config;
config.h = HostAndPort(hostName);
replConfig.insert(std::make_pair(hostName, config));
}
setConfig(replConfig);
}
/**************************************************
* Configure the Pi / touchIt
**************************************************/
void setup()
{
unsigned char len = 0;
unsigned char dir = IN;
static const char dir_str[] = "in\0out";
signal (SIGINT, exitHandler);
// Open the I2C bus (enable file access)
char *filename = (char *)"/dev/i2c-1";
if((file_i2c = open(filename, O_RDWR)) < 0)
{
printf("setup(): Failed to open the i2c bus\n");
return;
}
if(ioctl(file_i2c, I2C_SLAVE, TCHADD1) < 0)
{
printf("Failed to acquire bus access and/or talk to slave\n");
return;
}
// Enable GPIO to read touchIt 'int' pin
if((file_gpio = open("/sys/class/gpio/export", O_WRONLY)) < 0)
{
printf("setup(): Failed to open export for writing\n");
return;
}
else
{
len = snprintf(buffer, BUFMAX, "%d", intPin);
write(file_gpio, buffer, len);
close(file_gpio);
}
// Configure GPIO Direction as input
snprintf(buffer, DIRMAX, "/sys/class/gpio/gpio%d/direction", intPin);
if((file_gpio = open(buffer, O_WRONLY)) < 0)
{
printf("setup(): Failed to open gpio direction for writing\n");
return;
}
else
{
write(file_gpio, &dir_str[IN == dir ? 0:3], IN == dir ? 2:3);
close(file_gpio);
}
// Open gpio file for reading
snprintf(buffer, DIRMAX, "/sys/class/gpio/gpio%d/value", intPin);
if((file_gpio = open(buffer, O_RDONLY)) < 0)
{
printf("gpioRead(): failed to open gpio value for reading\n");
return;
}
getVersion();
setConfig(XMOVE | YMOVE);
}
ImageProcessor::ImageProcessor(SkinCamConfig aConfig)
:mouseClickNbhrd(7), cannyHighThresh(127), cannyLowThresh(127), cannyImage(0), medianKernel(7),
autoSelectCannyImage(false), lastSharpestBand(0),
distLowEnd(aConfig.distanceLowEnd), distHighEnd(aConfig.distanceHighEnd)
{
setConfig(aConfig);
}
TICC1100::TICC1100(std::shared_ptr<BaseLib::Systems::PhysicalInterfaceSettings> settings) : IPhysicalInterface(GD::bl, settings)
{
try
{
_out.init(GD::bl);
_out.setPrefix(GD::out.getPrefix() + "TI CC110X \"" + settings->id + "\": ");
if(settings->listenThreadPriority == -1)
{
settings->listenThreadPriority = 45;
settings->listenThreadPolicy = SCHED_FIFO;
}
if(settings->oscillatorFrequency < 0) settings->oscillatorFrequency = 26000000;
if(settings->txPowerSetting < 0) settings->txPowerSetting = 0xC0;
_transfer = { (uint64_t)0, (uint64_t)0, (uint32_t)0, (uint32_t)4000000, (uint16_t)0, (uint8_t)8, (uint8_t)0, (uint32_t)0 };
setConfig();
}
catch(const std::exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(BaseLib::Exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
}
Kiptables::Kiptables(const char *name,KIptablesConfig *config) : KTMainWindow(name)
{
setConfig(config);
initView();
initActions();
createGUI();
}
bool CDVRPTRV3Controller::openModem()
{
bool ret = false;
switch (m_connection) {
case CT_USB:
ret = m_usb->open();
break;
case CT_NETWORK:
ret = m_network->open();
break;
default:
wxLogError(wxT("Invalid connection type: %d"), int(m_connection));
break;
}
if (!ret)
return false;
ret = readSerial();
if (!ret) {
closeModem();
return false;
}
ret = setConfig();
if (!ret) {
closeModem();
return false;
}
return true;
}
void plDynamicTextMap::Create(unsigned int width, unsigned int height,
bool hasAlpha, unsigned int extraWidth,
unsigned int extraHeight) {
setConfig(kRGB8888);
fVisWidth = width;
fVisHeight = height;
fHasAlpha = hasAlpha;
fWidth = 1;
if (width + extraWidth > 1) {
while (fWidth < (width + extraWidth))
fWidth *= 2;
}
fHeight = 1;
if (height + extraHeight > 1) {
while (fHeight < (height + extraHeight))
fHeight *= 2;
}
fHasBeenCreated = true;
/*fFlags |= kDontThrowAwayImage;*/
fStride = fWidth * 4;
fLevelData.resize(1);
fCompressionType = kUncompressed;
fUncompressedInfo.fType = kRGB8888;
}
//__________________________________________________________________________
void Speller::Aspell::Suggest::resetConfig()
throw( std::invalid_argument, std::runtime_error )
{
delete_aspell_config( fconfig );
fconfig = new_aspell_config();
try
{
setConfig();
}
catch( const std::invalid_argument& err )
{
throw err;
}
AspellCanHaveError* ret = new_aspell_speller( fconfig );
if( aspell_error_number( ret ) != 0 )
{
delete_aspell_can_have_error( ret );
throw std::runtime_error( "(Aspell::Speller::Suggest::Reset"
"Config): Error in creating "
"speller." );
}
else
{
// Following statement causes a crash, hence commented out
//delete_aspell_speller( fspeller );
fspeller = to_aspell_speller( ret );
delete_aspell_config( fconfig );
fconfig = aspell_speller_config( fspeller );
}
}
/**
* Inicializa o mecanismo de log
*/
void initializeLog() {
// Desabilita o log
debugEnabled = 0;
// Obtem recurso para ativar log
enabledLog = getProperty(PROPERTY_LOG_ENABLED);
// Verifica se deve ativar o log
if (enabledLog != NULL && strcmp(enabledLog, "true") == 0) {
fileLogName = getProperty(PROPERTY_LOG_FILE);
if (fileLogName == NULL) {
fileLogName = LOG_FILE;
}
// Obtem output
output = getProperty(PROPERTY_LOG_OUTPUT);
// Ativa o log
debugEnabled = 1;
if (output != NULL) {
setConfig(atoi(output));
}
}
}
void ConfigDialogImpl::displayDialog()
{
ui = new Configdialog(0L, "configure", true);
connect(ui->buttonCancel, SIGNAL(clicked()), SLOT(slotCancel()));
connect(ui->buttonOk, SIGNAL(clicked()), SLOT(slotOk()));
setConfig();
ui->show();
}
void MediaCenter::setCoverSize(int coverSize)
{
if (m_coverSize != coverSize) {
m_coverSize = coverSize;
setConfig(GUI_COVER_SIZE, m_coverSize);
emit coverSizeChanged(m_coverSize);
}
}
void MediaCenter::setFullScreen(bool showFullScreen)
{
if (m_showFullScreen != showFullScreen) {
m_showFullScreen = showFullScreen;
setConfig(GUI_SHOW_FULLSCREEN, showFullScreen);
show();
emit fullScreenChanged();
}
}
uint8_t HDC1000::begin(uint8_t reset, uint8_t mode, uint8_t resolution, uint8_t heater){
Wire.begin();
uint8_t config = mode|resolution|heater|reset;
setConfig(config);
return config;
}
Converter::Converter(const char * config)
{
if (!initialized)
initialize();
handle = NULL;
m_loaded = false;
setConfig(config);
}
RobotConfig::RobotConfig(RobotWeakPtr robot, const std::string &name, const std::vector< Configuration > &configs)
: name(name),
robot(robot)
{
THROW_VR_EXCEPTION_IF(!robot.lock(),"NULL robot in RobotConfig");
for (std::vector< Configuration >::const_iterator i=configs.begin(); i!=configs.end(); i++ )
{
setConfig((*i));
}
}
RobotConfig::RobotConfig(RobotWeakPtr robot, const std::string &name, const std::map< RobotNodePtr, float > &configs)
: name(name),
robot(robot)
{
THROW_VR_EXCEPTION_IF(!robot.lock(),"NULL robot in RobotConfig");
for (std::map< RobotNodePtr, float >::const_iterator i=configs.begin(); i!=configs.end(); i++ )
{
setConfig(i->first,i->second);
}
}
FavoriteAppsModel::FavoriteAppsModel(QObject *parent)
: QAbstractListModel(parent)
{
QHash<int, QByteArray> roles;
roles.insert(Qt::DisplayRole, "label");
roles.insert(Qt::DecorationRole, "icon");
roles.insert(FavoriteIdRole, "favoriteId");
setRoleNames(roles);
setConfig(KSharedConfig::openConfig("salrc"));
}
void MainWindow::ClickSetting(){
Setting *setting = new Setting();
setting->exec();
setConfig();
delete setting;
}
