bool
Lorica::Proxy::setup_shutdown_handler(void)
{
ACE_Sig_Set sigset;
// Register signal handlers.
sigset.sig_add(SIGINT);
sigset.sig_add(SIGUSR1);
sigset.sig_add(SIGUSR2);
sigset.sig_add(SIGTERM);
// Register the <handle_signal> method to process all the signals in
// <sigset>.
ACE_Sig_Action sa(sigset,
(ACE_SignalHandler)Lorica::signal_handler);
ACE_UNUSED_ARG(sa);
return true;
}
int ft_dirread(s_dir *d, s_arg *a, char **argv)
{
int cd;
d->open = opendir(argv[a->arc]);
if (d->open == NULL)
return (1);
if(a->rm == 1)
srm(d,a, argv);
else
sa(d,a);
//cd = closedir(d->open);
return (0);
// ft_putnbr(d->rd->d_type);// permet de connaitre le type de fichir, un fichier standard = 8 et un dossier = 4
// ft_putnbr(d->info->st_mode);
// ft_putnbr(d->info->st_mode);
// ft_putchar('\n');
}
uint16_t SocketAcceptor::listen(const std::vector<std::string>& interfaces, uint16_t port, int backlog, const SocketFactory& factory)
{
std::vector<std::string> addresses = expandInterfaces(interfaces);
std::string sport(boost::lexical_cast<std::string>(port));
if (addresses.empty()) {
// We specified some interfaces, but couldn't find addresses for them
QPID_LOG(warning, "TCP/TCP6: No specified network interfaces found: Not Listening");
return 0;
}
int listeningPort = 0;
for (unsigned i = 0; i<addresses.size(); ++i) {
QPID_LOG(debug, "Using interface: " << addresses[i]);
SocketAddress sa(addresses[i], sport);
do {
try {
// If we were told to figure out the port then only allow listening to one address
if (port==0 && listeningPort!=0) {
// Print warning if the user specified more than one interface
QPID_LOG(warning, "Specified port=0: Only listened to: " << sa.asString());
return listeningPort;
}
QPID_LOG(info, "Listening to: " << sa.asString());
std::auto_ptr<Socket> s(factory());
uint16_t lport = s->listen(sa, backlog);
QPID_LOG(debug, "Listened to: " << lport);
addListener(s.release());
if (listeningPort==0) listeningPort = lport;
} catch (std::exception& e) {
QPID_LOG(warning, "Couldn't listen to: " << sa.asString() << ": " << e.what());
}
} while (sa.nextAddress());
}
if (listeningPort==0) {
throw Exception("Couldn't find any network address to listen to");
}
return listeningPort;
}
void resolve(t_stack *stack, char **argv)
{
get_list(stack, argv);
if (stack->number_in_a == 2)
sa(stack, 1);
while (stack->number_in_b || !is_sort(stack))
{
if (stack->number_in_a < 4)
quicky_sort(stack);
else
naive_algo(stack);
}
if (stack->number_of_moves)
ft_printf("Moves required : [%[[FG_GRE,SP_RST]d]\n", stack->n_moves);
if (stack->end_status)
print_stack(&stack->a_begin, stack->number_in_a, 'a', stack->color);
if (!stack->no_command)
print_command(stack);
free_stack(stack);
}
void ArrayTest8(ostream & buffer)
{
buffer << "\r\nArrays: String Object Example"
"\r\n-----------------------------\r\n";
SimpleArray<SimpleStr> sa(10);
sa[0] = SimpleStr("Zero");
sa[1] = "One";
sa[2] = "Two";
sa[3] = "Three";
sa[4] = "Four";
sa[5] = "Five";
sa[6] = "Six";
sa[7] = "Seven";
sa[8] = "Eight";
sa[9] = "Nine";
buffer << "String array test = " << sa << "\r\n";
}
void main()
{
int a[20], i, e;
printf("enter size of array\t");
scanf("%d", &n);
if (n >0)
{
printf("enter array elements:");
for (i = 0; i < n; i++)
scanf("%d", &a[i]);
printf("enter the element\t");
scanf("%d", &e);
sa(a, e);
printf("modified array\n");
for (i = 0; i < n; i++)
printf("%d\t", a[i]);
}
else
printf("invalid size");
}
void construct_sa(cache_config& config)
{
static_assert(t_width == 0 or t_width == 8 , "construct_sa: width must be `0` for integer alphabet and `8` for byte alphabet");
const char* KEY_TEXT = key_text_trait<t_width>::KEY_TEXT;
if (t_width == 8) {
typedef int_vector<t_width> text_type;
text_type text;
load_from_cache(text, KEY_TEXT, config);
// call divsufsort
int_vector<> sa(text.size(), 0, bits::hi(text.size())+1);
algorithm::calculate_sa((const unsigned char*)text.data(), text.size(), sa);
store_to_cache(sa, conf::KEY_SA, config);
} else if (t_width == 0) {
// call qsufsort
int_vector<> sa;
sdsl::qsufsort::construct_sa(sa, config.file_map[KEY_TEXT].c_str(), 0);
store_to_cache(sa, conf::KEY_SA, config);
} else {
std::cerr << "Unknown alphabet type" << std::endl;
}
}
/*!
* Constructor for building the Index
* \param[in] str C-string of the text
*/
index_csa_psi_text(const unsigned char *str) : index() {
size_t n = strlen((const char*)str);
int_vector<> sa(n+1, 0, bit_magic::l1BP(n+1)+1);
algorithm::calculate_sa(str, n+1, sa); // calculate the suffix array sa of str
int_vector<> m_psi;
sdsl::algorithm::sa2psi(sa, m_psi);
psi = EncVector(m_psi);
setText(str, n+1);
text = int_vector<>(sa.size(), 0, bit_magic::l1BP(sigma)+1);
for (size_t i=0; i<sa.size(); i++) text[i] = char2comp[str[i]];
/* Construct the SA-Samples */
m_sa_sample.setIntWidth( bit_magic::l1BP(sa.size())+1 );
m_sa_sample.resize( (sa.size()+SampleDens-1)/SampleDens );
size_t i=0, idx=0;
for(int_vector<>::const_iterator it = sa.begin(); i < sa.size(); it += (ptrdiff_t)SampleDens, i += SampleDens, ++idx) {
m_sa_sample[idx] = *it;
}
}
vector<int> btwEncode(const vector<int> &src) {
// O(n*lgn*lgn). probably faster than O(n*lgn) version
int len = src.size();
vector<int> sa(len), rank(len);
for(int i=0; i<len; ++i) rank[sa[i] = i] = src[i];
for(int ll=1, cnt=0; cnt!=len; ll<<=1, cnt=rank[sa.back()]+1) {
auto cmp = [&](const int l, const int r) {
if( rank[l]!=rank[r] ) return rank[l] < rank[r];
return rank[(l+ll)%len] < rank[(r+ll)%len];
};
sort(sa.begin(), sa.end(), cmp);
vector<int> tmp = rank;
tmp[sa[0]] = 0;
for(int i=1; i<sa.size(); ++i)
tmp[sa[i]] = tmp[sa[i-1]] + cmp(sa[i-1], sa[i]);
rank = tmp;
}
vector<int> rst(len);
for(int i=0; i<len; ++i) rst[i] = src[(sa[i]+len-1)%len];
return rst;
}
// O(N(lgN)^2)
std::vector<int> GetSuffixArray(const std::string& s) {
// sa, group, t
std::vector<int> sa(s.size());
for (int i = 0; i < s.size(); ++i)
sa[i] = i;
std::vector<int> group(s.size()+1, -1);
for (int i = 0; i < s.size(); ++i)
group[i] = s[i];
int t = 1;
while (true) {
printf("[%d] ---------------------------------------\n", t);
// sort suffix array
Comp c(s, group, t);
std::sort(sa.begin(), sa.end(), c);
printf("[%d] =======================================\n", t);
// PrintSuffixArray(s, sa);
// make new t
t *= 2;
// base condition
if (t >= s.size())
break;
// make new group for 2t
std::vector<int> group2(s.size() + 1, -1);
group2[sa[0]] = 0;
for (int i = 1; i < s.size(); ++i) {
if (c(sa[i-1], sa[i]))
group2[sa[i]] = group2[sa[i-1]] + 1;
else
group2[sa[i]] = group2[sa[i-1]];
}
group = group2;
}
return sa;
}
void fill_a(t_algo *algo, t_info *info)
{
t_list *last_a;
last_a = get_last(algo->stack_a);
while (algo->stack_b && (algo->op_count < info->in_count))
{
if ((algo->stack_b->next
&& *(int*)algo->stack_b->data < *(int*)algo->stack_b->next->data)
&& (algo->stack_a->next
&& *(int*)algo->stack_a->data > *(int*)algo->stack_a->next->data))
ss(algo);
if (algo->stack_b->next
&& *(int*)algo->stack_b->data < *(int*)algo->stack_b->next->data)
sb(algo);
if (algo->stack_a->next
&& *(int*)algo->stack_a->data > *(int*)algo->stack_a->next->data)
sa(algo);
pa(algo);
last_a = get_last(algo->stack_a);
}
}
_MEMBER_FUNCTION_IMPL( XmlNode, SetAttribute )
{
StackHandler sa(v);
_CHECK_SELF( TiXmlNode, XmlNode );
const char* szAttribute = (const char*)sa.GetString( 2 );
const char* szValue = (const char*)sa.GetString( 3 );
TiXmlElement* pNode = (TiXmlElement*)self;
if ( pNode )
{
pNode->SetAttribute( szAttribute, szValue );
sa.Return( true );
return 1;
}
sa.Return( false );
return 1;
}
//-----------------------------------------------------------------------------
// Name: SendVoiceMessage
// Desc: Sends a voice message over the network, to everyone (NULL) or a
// specific recipient.
//-----------------------------------------------------------------------------
int CVoiceManager::SendVoiceMessage( const VoiceMessage* pMsg, const CXBSockAddr* psaDest )
{
int nBytes = 0;
// Non-reliable message - these get sent directly via VDP in all cases
if( psaDest )
{
// If destined for a specific player, send straight to them
nBytes += m_DirectSock.SendTo( pMsg, pMsg->GetSize(), psaDest->GetPtr() );
}
else
{
// Send to our current list of voice targets:
for( int i = 0; i < numVoiceTargets; ++i )
{
CXBSockAddr sa( xbOnlineInfo.xbPlayerList[voiceTargets[i].index].inAddr, DIRECT_PORT );
nBytes += m_DirectSock.SendTo( pMsg, pMsg->GetSize(), sa.GetPtr() );
}
}
return nBytes;
}
_MEMBER_FUNCTION_IMPL( XmlNode, GetAttribute )
{
StackHandler sa(v);
_CHECK_SELF( TiXmlNode, XmlNode );
const char* szAttribute = (const char*)sa.GetString( 2 );
TiXmlElement* pNode = (TiXmlElement*)self;
if ( pNode )
{
const char* szValue = pNode->Attribute( szAttribute );
if ( szValue )
{
sa.Return( szValue );
return 1;
}
}
sq_pushnull( v );
return 1;
}
int checker_calc(t_e *e)
{
char *line;
while (get_next_line(0, &line) != 0)
{
if (ft_strcmp("sa", line) == 0)
sa(e->l_a);
else if (ft_strcmp("sb", line) == 0)
sb(e->l_b);
else if (ft_strcmp("ss", line) == 0)
ss(e->l_a, e->l_b);
else if (ft_strcmp("ra", line) == 0)
ra(e->l_a);
else if (ft_strcmp("rb", line) == 0)
rb(e->l_b);
else if (ft_strcmp("rr", line) == 0)
rr(e->l_a, e->l_b);
else if (ft_strcmp("rra", line) == 0)
rra(e->l_a);
else if (ft_strcmp("rrb", line) == 0)
rrb(e->l_b);
else if (ft_strcmp("rrr", line) == 0)
rrr(e->l_a, e->l_b);
else if (ft_strcmp("pa", line) == 0)
pa(e->l_a, e->l_b);
else if (ft_strcmp("pb", line) == 0)
pb(e->l_a, e->l_b);
else
{
ft_putendl_fd("Error", 2);
ft_memdel((void **)&line);
return (0);
}
ft_memdel((void **)&line);
}
return (1);
}
const HostEntry& DNS::hostByAddress(const IPAddress& address)
{
FastMutex::ScopedLock lock(_mutex);
#if defined(_WIN32) && defined(POCO_HAVE_IPv6)
SocketAddress sa(address, 0);
static char fqname[1024];
if (getnameinfo(sa.addr(), sa.length(), fqname, sizeof(fqname), NULL, 0, 0) == 0)
{
DNSCache::const_iterator it = _cache.find(std::string(fqname));
if (it != _cache.end())
{
return it->second;
}
else
{
struct addrinfo* pAI;
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
if (getaddrinfo(fqname, NULL, &hints, &pAI) == 0)
{
std::pair<DNSCache::iterator, bool> res = _cache.insert(std::pair<std::string, HostEntry>(std::string(fqname), HostEntry(pAI)));
freeaddrinfo(pAI);
return res.first->second;
}
}
}
#else
struct hostent* he = gethostbyaddr(reinterpret_cast<const char*>(address.addr()), address.length(), address.af());
if (he)
{
std::pair<DNSCache::iterator, bool> res = _cache.insert(std::pair<std::string, HostEntry>(std::string(he->h_name), HostEntry(he)));
return res.first->second;
}
#endif
error(lastError(), address.toString()); // will throw an appropriate exception
throw NetException(); // to silence compiler
}
void CStackerManager::UpdateDrawing(void)
{
DISPPARAMS dp = {NULL, NULL, 0, 0};
DISPPARAMS dpNULL = {NULL, NULL, 0, 0};
CComVariant vPars[2];
CComSafeArray<double> sa(2);
EXCEPINFO einfo;
HRESULT hr;
DRAWING_MODE nMode;
dp.cArgs = 2;
dp.rgvarg = vPars;
if(NULL != pOGLViewer)
{
// Clear Drawing
hr = pOGLViewer->Invoke(4,IID_NULL,LOCALE_SYSTEM_DEFAULT,DISPATCH_METHOD,&dpNULL,NULL,&einfo,NULL);
int nSize = StackerArray.size();
for(int i = 0; i < StackerArray.size(); i++)
{
int nCount = StackerArray[i]->GetNoDrawingPackets();
for (int j = 1; j <= nCount; j++)
{
StackerArray[i]->GetDrawingPacket(j,nMode,sa);
vPars[0] = sa;
vPars[1] = nMode;
hr = pOGLViewer->Invoke(2,IID_NULL,LOCALE_SYSTEM_DEFAULT,DISPATCH_METHOD,&dp,NULL,&einfo,NULL);
}
}
// Update Drawing
hr = pOGLViewer->Invoke(5,IID_NULL,LOCALE_SYSTEM_DEFAULT,DISPATCH_METHOD,&dpNULL,NULL,&einfo,NULL);
}
}
template< class T > T Correlation< T >::operator () (const vector < T > & a, const vector < T > & b) const
{
static char F_Name[] = "template< class T > T Correlation< T >::operator () (const vector < T > & a, const vector < T > & b) const";
if(a.size() != b.size()) {
TKVPairList kvlist;
kvlist.push_back(TKVPair("Size", a.size()));
kvlist.push_back(TKVPair("Size", b.size()));
throw IndexError(F_Name, kvlist);
}
T av_a, av_b, d_a, d_b, sp(0), sa(0), sb(0);
av_a = average(a);
av_b = average(b);
for(unsigned i=0; i<a.size(); i++) {
d_a = a[i] - av_a;
d_b = b[i] - av_b;
sp += d_a * d_b;
sa += SQR(d_a);
sb += SQR(d_b);
}
return sp / sqrt(sa * sb);
}
_MEMBER_FUNCTION_IMPL( XmlElement, NextSiblingElement )
{
StackHandler sa( v );
_CHECK_SELF( TiXmlElement, XmlElement );
int iArgs = sa.GetParamCount();
if ( iArgs == 1 )
{
TiXmlElement* xmlElement = self->NextSiblingElement();
if ( xmlElement ) return push_XmlElement( xmlElement );
else return false;
}
else if ( iArgs == 2 )
{
const SQChar* szValue = sa.GetString( 2 );
TiXmlElement* xmlElement = self->NextSiblingElement( (char*)szValue );
if ( xmlElement ) return push_XmlElement( xmlElement );
else return false;
}
return sa.ThrowError( "XmlElement::NextSiblingElement() failed" );
}
_MEMBER_FUNCTION_IMPL( XmlDocument, FirstChildElement )
{
StackHandler sa( v );
_CHECK_SELF( TiXmlDocument, XmlDocument );
int iArgs = sa.GetParamCount();
if ( iArgs == 1 )
{
push_XmlElement( (TiXmlElement*)self->FirstChildElement() );
return 1;
}
else if ( iArgs == 2 )
{
const SQChar* szValue = sa.GetString( 2 );
push_XmlElement( (TiXmlElement*)self->FirstChildElement( (char*)szValue ) );
return 1;
}
return sa.ThrowError( "XmlDocument::FirstChildElement() failed" );
}
vector<int> buildSuffixArray(const vector<int> &str, int endOfString=-1) {
// sa: i -> start position of str
// O(n*lgn*lgn). probably faster than O(n*lgn) version
int len = str.size();
vector<int> sa(len+1), rank(len+1);
for(int i=0; i<len; ++i) rank[sa[i] = i] = str[i];
rank[sa.back() = len] = endOfString;
for(int ll=1, cnt=0; cnt!=len; ll<<=1, cnt=rank[sa.back()]) {
auto cmp = [&](const int l, const int r) {
if( rank[l]!=rank[r] ) return rank[l] < rank[r];
int lv = (l+ll < len) ? rank[l+ll] : 0;
int rv = (r+ll < len) ? rank[r+ll] : 0;
return lv < rv;
};
sort(sa.begin(), sa.end(), cmp);
vector<int> tmp = rank;
tmp[sa[0]] = 0;
for(int i=1; i<sa.size(); ++i)
tmp[sa[i]] = tmp[sa[i-1]] + cmp(sa[i-1], sa[i]);
rank = tmp;
}
return sa;
}
void checktwolast(t_ps *ps)
{
t_dnode *current;
t_dnode *prev;
if (stacklen(ps->stacka) > 4)
{
current = ps->stacka->list;
while (current->next)
{
prev = current;
current = current->next;
}
if (prev->value > current->value)
{
rra(ps);
rra(ps);
sa(ps);
ra(ps);
ra(ps);
}
}
}
void ft_put_sol(unsigned int i, char op, t_swap **ba, t_swap **bb)
{
if (i / 8)
ft_put_sol(i / 8, op, ba, bb);
if (i % 8 == 0)
{
ft_putstr("sa ");
op ? sa(ba) : 0;
}
else if (i % 8 == 1)
{
ft_putstr("ra ");
op ? ra(ba) : 0;
}
else if (i % 8 == 2)
{
ft_putstr("rra ");
op ? rra(ba) : 0;
}
ft_suite_de_merde(i, op, ba, bb);
op ? ft_print_list(*ba, 1) : 0;
op ? ft_print_list(*bb, 0) : 0;
}
vector<SockAddr> ipToAddrs(const char* ips, int port, bool useUnixSockets) {
vector<SockAddr> out;
if (*ips == '\0') {
out.push_back(SockAddr("0.0.0.0", port)); // IPv4 all
if (IPv6Enabled())
out.push_back(SockAddr("::", port)); // IPv6 all
#ifndef _WIN32
if (useUnixSockets)
out.push_back(SockAddr(makeUnixSockPath(port).c_str(), port)); // Unix socket
#endif
return out;
}
while(*ips) {
string ip;
const char * comma = strchr(ips, ',');
if (comma) {
ip = string(ips, comma - ips);
ips = comma + 1;
}
else {
ip = string(ips);
ips = "";
}
SockAddr sa(ip.c_str(), port);
out.push_back(sa);
#ifndef _WIN32
if (useUnixSockets && (sa.getAddr() == "127.0.0.1" || sa.getAddr() == "0.0.0.0")) // only IPv4
out.push_back(SockAddr(makeUnixSockPath(port).c_str(), port));
#endif
}
return out;
}
//-----------------------------------------------------------------------------
// Name: SendVoiceInfo()
// Desc: Issue a MSG_VOICEINFO from ourself (either a host or player) to
// another player
//-----------------------------------------------------------------------------
void CVoiceManager::SendVoiceInfo( VOICEINFO action,
XBPlayerInfo* pDestPlayer )
{
InfoMessage msgVoiceInfo;
MsgVoiceInfo& msg = msgVoiceInfo.GetMsgVoiceInfo();
msg.action = action;
msg.srcRefIndex = xbOnlineInfo.xbPlayerList[xbOnlineInfo.localIndex].refIndex;
// Send the message reliably - whether it's sent to all players
// or just to one specific player is determined by what the
// caller passed in for pDestPlayer
INT nBytes;
if( pDestPlayer )
{
// Send the voice info message reliably to the player
// (note that it may be relayed by the host)
msg.dstRefIndex = pDestPlayer->refIndex;
CXBSockAddr sa( pDestPlayer->inAddr, DIRECT_PORT );
nBytes = SendInfoMessage( &msgVoiceInfo, &sa );
}
else
{
// Send the voice info message reliably to all players in the game
// (note that it will definitely be relayed by the host)
msg.dstRefIndex = -1;
nBytes = SendInfoMessage( &msgVoiceInfo );
}
// This assert was removed because Send no longer is guaranteed to always work
// If the security association times out, the number of bytes returned will
// NOT be equal to the size of the message. A good thing to do here would
// be to drop the player
//assert( nBytes == SOCKET_ERROR || nBytes == msgVoiceInfo.GetSize() );
(void)nBytes;
}
void KeyFinder::chromagramOfBufferedAudio(
Workspace& workspace,
const Parameters& params
) {
if (workspace.getFftAdapter() == NULL)
workspace.setFftAdapter(new FftAdapter(params.getFftFrameSize()));
SpectrumAnalyser sa(workspace.buffer.getFrameRate(), params, ctFactory);
Chromagram* c = sa.chromagramOfWholeFrames(workspace.buffer, workspace.getFftAdapter());
// deal with tuning if necessary
if (c->getBandsPerSemitone() > 1) {
if (params.getTuningMethod() == TUNING_BAND_ADAPTIVE) {
c->tuningBandAdaptive(params.getDetunedBandWeight());
} else if (params.getTuningMethod() == TUNING_HARTE) {
c->tuningHarte();
}
}
workspace.buffer.discardFramesFromFront(params.getHopSize() * c->getHops());
if (workspace.chroma == NULL) {
workspace.chroma = c;
} else {
workspace.chroma->append(*c);
delete c;
}
}
void algobubble(t_ps *ps)
{
int order;
int i;
i = 0;
if (stacklen(ps->stacka) > 0 && stackorder(ps->stacka) != 0)
{
checktwolast(ps);
order = 0;
while (stackorder(ps->stacka) > 0 && i < BUBBLE_MAX)
{
order = stackorder(ps->stacka);
if (ps->stacka->list->value > ps->stacka->list->next->value &&
ps->stacka->list->value != ps->stacka->start->value)
sa(ps);
else
ra(ps);
i++;
}
if (stackorder(ps->stacka) > 0)
ps->bad = 1;
}
}
void testObj::test<8>(void)
{
// making timestamp for all calls prevents timing issues.
const Timestamp now=Timestamp(123456);
Persistency::MetaAlertPtrNN maPtrNode( new Persistency::MetaAlert( Persistency::MetaAlert::Name("meta alert node"),
0.1, 0.2,
makeNewReferenceURL().shared_ptr(),
now,
1410u ) );
Persistency::IO::Postgres::MetaAlert malertNode(maPtrNode, t_, dbh_);
Persistency::Alert::Analyzers sa( AnalyzerPtrNN( new Analyzer(42u, "analyzer name", NULL, NULL, NULL) ) );
Persistency::AlertPtrNN alertPtr(new Persistency::Alert("abc",
sa,
NULL,
now,
Severity(SeverityLevel::INFO),
Certainty(0.42),
"some description",
Persistency::Alert::Hosts(),
Persistency::Alert::Hosts()) );
Persistency::IO::Postgres::Alert alert(alertPtr, t_, dbh_);
malertNode.save();
alert.save();
malertNode.associateWithAlert( alertPtr );
const DataBaseID malertNodeID=dbh_->getIDCache()->get( maPtrNode );
const DataBaseID alertID =dbh_->getIDCache()->get( alertPtr );
stringstream ss;
ss << "SELECT * FROM alert_to_meta_alert_map WHERE id_alert = " << alertID << ";";
const result r = t_.getAPI<TransactionAPI>().exec(ss);
ensure_equals("invalid size",r.size(), 1u);
ensure_equals("invalid Alert ID", ReaderHelper<DataBaseID>::readAsNotNull(r[0]["id_meta_alert"]), malertNodeID);
ensure_equals("invalid MetaAlert ID", ReaderHelper<DataBaseID>::readAsNotNull(r[0]["id_alert"]), alertID);
t_.commit();
}
SQInteger EditPairDlg_Ctor(HSQUIRRELVM v)
{
// (wxWindow* parent,
// wxString& key,
// wxString& value,
// const wxString& title = _("Edit pair"),
// BrowseMode allowBrowse = bmDisable);
StackHandler sa(v);
EditPairDlg* dlg = 0;
if (sa.GetParamCount() > 4)
{
dlg = new EditPairDlg(0,
*SqPlus::GetInstance<wxString,false>(v, 2),
*SqPlus::GetInstance<wxString,false>(v, 3),
*SqPlus::GetInstance<wxString,false>(v, 4),
(EditPairDlg::BrowseMode)sa.GetInt(5));
}
else if (sa.GetParamCount() > 3)
{
dlg = new EditPairDlg(0,
*SqPlus::GetInstance<wxString,false>(v, 2),
*SqPlus::GetInstance<wxString,false>(v, 3),
*SqPlus::GetInstance<wxString,false>(v, 4));
}
else if (sa.GetParamCount() > 2)
{
dlg = new EditPairDlg(0,
*SqPlus::GetInstance<wxString,false>(v, 2),
*SqPlus::GetInstance<wxString,false>(v, 3));
}
else
return sa.ThrowError("EditPairDlg needs at least two arguments");
return SqPlus::PostConstruct<EditPairDlg>(v, dlg, EditPairDlg_Dtor);
}
CRef<CSeq_align>
CreateSeqAlignFromAnchoredAln(const CAnchoredAln& anchored_aln,
CSeq_align::TSegs::E_Choice choice,
CScope* scope)
{
CRef<CSeq_align> sa(new CSeq_align);
sa->SetType(CSeq_align::eType_not_set);
sa->SetDim(anchored_aln.GetDim());
switch(choice) {
case CSeq_align::TSegs::e_Dendiag:
CreateDense_diagFromAnchoredAln(sa->SetSegs().SetDendiag(), anchored_aln, scope);
break;
case CSeq_align::TSegs::e_Denseg:
sa->SetSegs().SetDenseg(*CreateDensegFromAnchoredAln(anchored_aln, scope));
break;
case CSeq_align::TSegs::e_Std:
break;
case CSeq_align::TSegs::e_Packed:
sa->SetSegs().SetPacked(*CreatePackedsegFromAnchoredAln(anchored_aln, scope));
break;
case CSeq_align::TSegs::e_Disc:
sa->SetSegs().SetDisc(*CreateAlignSetFromAnchoredAln(anchored_aln, scope));
break;
case CSeq_align::TSegs::e_Spliced:
sa->SetSegs().SetSpliced(*CreateSplicedsegFromAnchoredAln(anchored_aln, scope));
break;
case CSeq_align::TSegs::e_Sparse:
break;
case CSeq_align::TSegs::e_not_set:
NCBI_THROW(CAlnException, eInvalidRequest,
"Invalid CSeq_align::TSegs type.");
break;
}
return sa;
}
