PibiCo's Portfolio
It is known that an adequate project management allows to get profits. Suppliers and Customers must be managed. We talk about scope, strategy, scheduling, resource planning. We include support for every business process at technical level and we can take care of organization and people coaching or training in Methods of Statement.
We offer Document Management and Valorization. The Document process includes: document capture, management, audit, filing, collaboration, backup and delivery. With the comprehensive and fully integrated Document LifeCycle Process you will have the definitive tool for becoming an Enterprise 4.0
Tools evolved like bikes did. Mankind has become digital. From data to Information. Our digital tools based on open-source software allow impressive performance. Ask for a show Room
PibiCo's Values
We adapt our services to the Client and Business Needs. We provide a full commitment with the best work done and trust in our expert engineers. Our future is in the people, so we take care of them.
Sure something is delayed if it's not started. Projects and Resources should be prepared and scheduled properly and on time. Preparation works become fundamental and Project Controls are a must in order to get success.
We are Engineers with a wide expertise in Engineering, Digital Tools, Enterprise Organizacion, Project Management, Contract Management in Industry and Engineering and Construction Projects in a wide set of Business Sectors.
52
+1.36%Customers
87
Suppliers
3600
-2.43%Year MenHour
15
Projects
The Goal
The objective of this Web App is the Management with IoT in Training Sessions where the students carry wearables and IoT Devices to improve the learning process and collect important data to get better results.
The App
Based on open source software and libraries, fully autonomous and secure, easily maintained and scalable, with standard hardware, capable of future evolutions or upgrades, using the last technologies and state-of-art in IoT.
The Results
The user will communicate to devices easily, and communicate directly between Instructors, Trainees, Equipment and Environment in a completely integrated process.
The Developer
PibiCo is a young Company with Expert Engineers in Control Management Systems, Management with IoT(MIoT) and Digital Valorization.


Our Process of Development is Agile. We Look forward to our great customer satisfaction. The Maintainence is always will be in our hands and hustle free. It is Very Important for us to provide the best instead of the first.
With the Power of Some Amazing Talents, We thrive to reach the top. By Following Excellence Our Only wish is to Maintain the Same Passion Forever
With the Smart Working Skills, Our Employees will always be interactive with each other. The Collaboration between every department is what makes us special from others
We Process our jobs with the efficiency and the determination to complete the project. Our Policy is to Complete the Project rather than completing the Individual task in quick time
We develop Static and Dynamic Websites with the best in class features
We Use HTML5 to Make the Websites better and to Align for all the Screen Sizes. From Mobile Displays to Retina Displays, We Make your Website More Powerful
The Perfection in Design and the Allignment of Elements make your website to attract more visitors and to grow your business better
Clean Code Technology is the Technology which Uses the Latest Code scripts and the Dynamic Libraries to Provide the Better Optimization for your website which makes it to load faster across all devices
We Cost for what we build, Customer satisfaction is the first Priority to us. More you stay with us, Deep the relationship we build with you. We never Let you go
We Do Websites for Almost Any Occassion
We Build for all type of Businesses and even for the Personnel Uses. With the Team we got, You Just need to accept our design coz of it's Brilliance. The Stable Performance when the Site Loads is the Key for any website and We have a Seperate Dedicated team to check and Make your Website more Special and Accessible anywhere with ease. We Even try to Preserve Memories of the people with their Personnel Website maintainence. Build a Relation withUs and We are sure that u Never Break it.
The Cheif Architects of Inspired Memories
Co-Founder, QA & CEO with Programming Skills. Completed Engineering in Electronics and Passionate towards Software Quality Analysis. Helping in Bringing the Best Quality Products to the Customers. She is the Reason for IM Technologies to be in this Level.
Co-Founder & Developer (Full Stack). A Tech Savy & an Engineering Graduate in Information Science. Passionate in Web Development, Programming and DevOps.
Front-End Developer An Engineering Graduate in Electronics and a Voilinist. Having a Strong Foundation in Doing Something Big with ability to persue the passion
Founders of this Organisation are Ms. Spoorthi and Mr. Vishriuth along with their friends made a perfect team of understanding. Spoorthi Concentrates mainly on the Quality of the Product and Others look after the Development. Every Person in Our Company is agile and Flexible for any situatiion. Founders by name but Workers by Nature
Our Well Satisfied Projects and about them
We have taken the Primary Project of Building a website for the Enterprise Company named Suhas Printers and We did it very happily and they Continued the relationship with us take a look at it
It Handles all the Information about the Students and The Queries reagrding about their Academic activities & Reports to Placement Department A New well Designed Portal along with the Landing Page makes PMS a Powerful Web app for your Organisation.
Take a Look at our Methodology that we follow to deliver you the best quality product
The Primary part of our Workflow is to Analyse what is the best thing for the customers in design. Planning further with given requirements is our first step.
RequirementsWe prepare the perfect understandable Documentation for our Employees as well as to our customer if they required. The Design of the Website will be deided by Including the Customers in our Outbound Meetings.
DesignAll of Our Workers will be involved in this phase. Every Employee works in Every Department to make the Continous Delivery Pipeline Enabled. Operations Team will take care of your traffic and SEO Phases
DevOpsAs we Include our Customer throughout the process of Development, After We discuss together about the Changing Requirements and Finalizing the Work. It Depends on How Customer Wants with us.
CrossingBefore Launching, We test it in Every Environment, the customer will also get to look at the completed application and Using Straight through
ReleaseWe make your app to go live and still in here, If u want to add more features we will just do that for you in our Incremental release Maintainence. We provide you the freedom to change anything and to Apply them easily in no time
PubishingWE are not also a Website Making Company We also Do Some R & D
The Good News for Everyone is, We are giing away 21 Websites for free. Whatever we make the first 21 Websites for any organisation, We will be delivering for free excluding Domain Charges.
We are Working on the Plan to Launch an Ecommerce Website which Makes Shopping easy and We are researching the new way to make customers feel happy about shopping. The Fun in the Making will be made fun in Buying too
Project S is the Social Network which we are researching on making it more Interactive with some cool animations and character creations. The Network That Responds to the user feelings. A True Friend of One's Life
Every Developer is Welcome to Our Company to Contribute. Everyone Around the World can Join Us. We are Open to all the Passionates. IMT is a Learners Club and a destination for Achievers
Donec sed odio dui. Etiam porta sem malesuada magna mollis euismod.
*Many Website Development Companies Offer Different Prices which May be Low or High. We Provide the Best Quality Web App for you with the affordable cost and If you don't get satisfaction, We will again Rebuild it For You. Our Service for you will be the best
The Details Where You Can Contact Us at Anytime
Inspired Memories or IM Technologies is a Software Technology Company founded by 2 Best friends. The Story is Simple, After Witnessing the World, We Started to Make this World a Better Place by Collaborating Technology and the People. Our Motto is "Driving Innovation" Everyday of Everyon's Life.
Or follow us on social platform
© 2016 Inspired Memories
We Drive the Best Force Within Us to Motivate Our World and the Passion within, Taken Us to Inspired Memories


Where can I find my Publisher ID?
Your Publisher ID is the ID on which the Asset Store APIs refer to you as Publisher. This same ID can be found at the URL of your store Home Page. As shown in the image below.
Where can I find my Reviews RSS URL?
Your Reviews RSS URL is a URL that displays all the latest Reviews made for your Assets. It can be found in the "Reviews" tab on your Publisher Portal in the Asset Store.
Page generated by Publisher Tools For Asset Store Extension


First Steps
POCO Data is POCO's database abstraction layer which allows users to easily send/retrieve data to/from various databases. Currently supported database connectors are SQLite, MySQL and ODBC. Framework is opened for extension, so additional native connectors (Oracle, PostgreSQL, ...) can be added. The intent behind the Poco::Data framework is to produce the integration between C++ and relational databses in a simple and natural way.
The following complete example shows how to use POCO Data:
#include "Poco/Data/Session.h" #include "Poco/Data/SQLite/Connector.h" #include <vector> #include <iostream> using namespace Poco::Data::Keywords; using Poco::Data::Session; using Poco::Data::Statement; struct Person { std::string name; std::string address; int age; }; int main(int argc, char** argv) { // register SQLite connector Poco::Data::SQLite::Connector::registerConnector(); // create a session Session session("SQLite", "sample.db"); // drop sample table, if it exists session << "DROP TABLE IF EXISTS Person", now; // (re)create table session << "CREATE TABLE Person (Name VARCHAR(30), Address VARCHAR, Age INTEGER(3))", now; // insert some rows Person person = { "Bart Simpson", "Springfield", 12 }; Statement insert(session); insert << "INSERT INTO Person VALUES(?, ?, ?)", use(person.name), use(person.address), use(person.age); insert.execute(); person.name = "Lisa Simpson"; person.address = "Springfield"; person.age = 10; insert.execute(); // a simple query Statement select(session); select << "SELECT Name, Address, Age FROM Person", into(person.name), into(person.address), into(person.age), range(0, 1); // iterate over result set one row at a time while (!select.done()) { select.execute(); std::cout << person.name << " " << person.address << " " << person.age << std::endl; } return 0; }
The above example is pretty much self explanatory.
The using namespace Poco::Data is for convenience only but highly recommended for good readable code. While ses << "SELECT COUNT(*) FROM PERSON", Poco::Data::Keywords::into(count), Poco::Data::Keywords::now; is valid, the aesthetic aspect of the code is improved by eliminating the need for full namespace qualification; this document uses convention introduced in the example above.
The remainder of this tutorial is split up into the following parts:
- Sessions
- Inserting and Retrieving Data
- Statements
- STL Containers
- Tuples
- Limits, Ranges and Steps
- RecordSets, Iterators and Rows
- Complex data types: how to map C++ objects to a database table
- Conclusion
Creating Sessions
Sessions are created via the Session constructor:
Session session("SQLite", "sample.db");
The first parameter contains the type of the Session one wants to create. Currently, supported backends are "SQLite", "ODBC" and "MySQL". The second parameter contains the connection string.
In the case of SQLite, the path of the database file is sufficient as connection string.
For ODBC, the connection string may be a simple "DSN=MyDSNName" when a DSN is configured or a complete ODBC driver-specific connection string defining all the necessary connection parameters (for details, consult your ODBC driver documentation).
For MySQL, the connection string is a semicolon-delimited list of name-value pairs specifying various parameters like host, port, user, password, database, compression and automatic reconnect. Example: "host=localhost;port=3306;db=mydb;user=alice;password=s3cr3t;compress=true;auto-reconnect=true"
Inserting and Retrieving Data
Single Data Sets
Inserting data works by using the content of other variables. Assume we have a table that stores only forenames:
ForeName (Name VARCHAR(30))
If we want to insert one single forename we could simply write:
std::string aName("Peter"); session << "INSERT INTO FORENAME VALUES(" << aName << ")", now;
However, a better solution is to use placeholders and connect each placeholder via a use expression with a variable that will provide the value during execution. Placeholders, depending on your database are recognized by having either a colon(:) in front of the name or simply by a question mark (?) as a placeholder. While having the placeholders marked with a colon followed by a human-readable name is very convenient due to readability, not all SQL dialects support this and universally accepted standard placeholder is (?). Consult your database SQL documentation to determine the valid placeholder syntax.
Rewriting the above code now simply gives:
std::string aName("Peter"); ses << "INSERT INTO FORENAME VALUES(?)", use(aName), now;
In this example the use expression matches the placeholder with the Peter value. Note that apart from the nicer syntax, the real benefits of placeholders — which are performance and protection against SQL injection attacks — don't show here. Check the Statements section to find out more.
Retrieving data from the Database works similar. The into expression matches the returned database values to C++ objects, it also allows to provide a default value in case null data is returned from the database:
std::string aName; ses << "SELECT NAME FROM FORENAME", into(aName), now; ses << "SELECT NAME FROM FORENAME", into(aName, 0, "default"), now;
You'll note the integer zero argument in the second into() call. The reason for that is that Poco::Data supports multiple result sets for those databases/drivers that have such capbility and we have to indicate the resultset we are referring to. Attempting to create sufficient overloads of into() creates more trouble than what it's worth and null values can effectively be dealt with through use of either Poco::Nullable wrapper (see Handling Null Entries later in this document) or Poco::Dynamic::Var, which will be set as empty for null values when used as query output target.
It is also possible to combine into and use expressions:
std::string aName; std::string match("Peter") ses << "SELECT NAME FROM FORENAME WHERE NAME=?", into(aName), use(match), now; poco_assert (aName == match);
Typically, tables will not be so trivial, i.e. they will have more than one column which allows for more than one into/use.
Lets assume we have a Person table that contains an age, a first and a last name:
std::string firstName("Peter"; std::string lastName("Junior"); int age = 0; ses << INSERT INTO PERSON VALUES (?, ?, ?)", use(firstName), use(lastName), use(age), now; ses << "SELECT (firstname, lastname, age) FROM Person", into(firstName), into(lastName), into(age), now;
Most important here is the order of the into and use expressions. The first placeholder is matched by the first use, the 2nd by the 2nd use etc.
The same is true for the into statement. We select firstname as the first column of the result set, thus into(firstName) must be the first into clause.
Handling NULL entries
A common case with databases are optional data fields that can contain NULL. To accomodate for NULL, use the Poco::Nullable template:
std::string firstName("Peter"; Poco::Nullable<std::string> lastName("Junior"); Poco::Nullable<int> age = 0; ses << INSERT INTO PERSON VALUES (?, ?, ?)", use(firstName), use(lastName), use(age), now; ses << "SELECT (firstname, lastname, age) FROM Person", into(firstName), into(lastName), into(age), now; // now you can check if age was null: if (!lastName.isNull()) { ... }
The above used Poco::Nullable is a lightweight template class, wrapping any type for the purpose of allowing it to have null value.
If the returned value was null, age.isNull() will return true. Whether empty string is null or not is more of a philosophical question (a topic for discussion in some other time and place); for the purpose of this document, suffice it to say that different databases handle it differently and Poco::Data provides a way to tweak it to user's needs through folowing Session features:
- emptyStringIsNull
- forceEmptyString
So, if your database does not treat empty strings as null but you want Poco::Data to emulate such behavior, modify the session like this:
ses.setFeature("emptyStringIsNull", true);
On the other side, if your database treats empty strings as nulls but you do not want it to, you'll alter the session feature:
ses.setFeature("forceEmptyString", true);
Obviously, the above features are mutually exclusive; an attempt to se them both to true will result in an exception being thrown by the Data framework.
Multiple Data Sets
Batches of statements are supported. They return multiple sets of data, so into() call needs and additional parameter to determine which data set it belongs to:
typedef Tuple<std::string, std::string, std::string, int> Person; std::vector<Person> people; Person pHomer, pLisa; int aHomer(42), aLisa(10), aBart(0); session << "SELECT * FROM Person WHERE Age = ?; " "SELECT Age FROM Person WHERE FirstName = 'Bart'; " "SELECT * FROM Person WHERE Age = ?", into(pHomer, 0), use(aHomer), into(aBart, 1), into(pLisa, 2), use(aLisa), now;
Note
Batches of statements can be used, provided, of course, that the target driver and database engine properly support them. Additionally, the exact SQL syntax may vary for different databases. Stored procedures (see below) returning multiple data sets are handled in the same way.
Now
And now, finally, a word about the now keyword. The simple description is: it is a manipulator. As it's name implies, it forces the immediate execution of the statement. If now is not present, the statement must be executed separately in order for anything interesting to happen.
More on statements and manipulators in the chapters that follow.
Stored Procedures And Functions Support
Most of the modern database systems support stored procedures and/or functions. Does Poco::Data provide any support there? You bet. While the specifics on what exactly is possible (e.g. the data types passed in and out, automatic or manual data binding, binding direction, etc.) is ultimately database dependent, POCO Data does it's best to provide reasonable access to such functionality through in, out and io binding functions. As their names imply, these functions are performing parameters binding tho pass in or receive from the stored procedures, or both. The code is worth thousand words, so here's an Oracle ODBC example:
session << "CREATE OR REPLACE " "FUNCTION storedFunction(param1 IN OUT NUMBER, param2 IN OUT NUMBER) RETURN NUMBER IS " " temp NUMBER := param1; " " BEGIN param1 := param2; param2 := temp; RETURN(param1+param2); " " END storedFunction;" , now; int i = 1, j = 2, result = 0; session << "{? = call storedFunction(?, ?)}", out(result), io(i), io(j), now; // i = 2, j = 1, result = 3
Stored procedures are allowed to return data sets (a.k.a. cursors):
typedef Tuple<std::string, std::string, std::string, int> Person; std::vector<Person> people; int age = 13; session << "CREATE OR REPLACE " "FUNCTION storedCursorFunction(ageLimit IN NUMBER) RETURN SYS_REFCURSOR IS " " ret SYS_REFCURSOR; " "BEGIN " " OPEN ret FOR " " SELECT * FROM Person WHERE Age < ageLimit; " " RETURN ret; " "END storedCursorFunction;" , now; session << "{call storedCursorFunction(?)}", in(age), into(people), now;
The code shown above works with Oracle databases.
A Word of Warning
As you may have noticed, in the above example, C++ code works very closely with SQL statements.  So it is your responsibility to make sure your SQL statements have the proper structure that corresponds to the number and type of the supplied functions.
Statements
We often mentioned the term Statement in the previous section, but with the exception of the initial example, we have only worked with database session objects so far. Or at least, that's what we made you believe.
In reality, you have already worked with Statements. Lets take a look at the method signature of the << operator at Session:
template <typename T> Statement Session::operator << (const T& t);
Simply ignore the template stuff in front, you won't need it. The only thing that counts here is that the operator << creates a Statement internally and returns it.
What happened in the previous examples is that the returned Statement was never assigned to a variable but simply passed on to the now part which executed the statement. Afterwards the statement was destroyed.
Let's take one of the previous examples and change it so that we assign the statement:
std::string aName("Peter"); Statement stmt = ( ses << "INSERT INTO FORENAME VALUES(?)", use(aName) );
Note that the brackets around the right part of the assignment are mandatory, otherwise the compiler will complain.
What did we achieve by assigning the statement to a variable? Two things: Control when to execute and the possibility to create a RecordSet (described in its own chapter below).
Here's how we control when to actually execute the statement:
std::string aName("Peter"); Statement stmt = ( ses << "INSERT INTO FORENAME VALUES(?)", use(aName) ); stmt.execute(); poco_assert (stmt.done());
By calling execute we asserted that our query was executed and that the value was inserted. The check to stmt.done() simply guarantees that the statement was fully completed.
Prepared Statements
A prepared statement is created by omitting the "now" clause.
Statement stmt = ( ses << "INSERT INTO FORENAME VALUES(?)", use(aName) );
The advantage of a prepared statement is performance. Assume the following loop:
std::string aName; Statement stmt = ( ses << "INSERT INTO FORENAME VALUES(?)", use(aName) ); for (int i = 0; i < 100; ++i) { aName.append("x"); stmt.execute(); }
Instead of creating and parsing the Statement 100 times, we only do this once and then use the placeholder in combination with the use clause to insert 100 different values into the database.
Still, this isn't the best way to insert a collection of values into a database. Poco::Data is STL-aware and will cooperate with STL containers to extract multiple rows from the database. More on that in the chapter titled "STL Containers".
Asynchronous Execution
So far, the statements were executing synchronously. In other words, regardless of whether the execute() method was invoked indirectly through now manipulator or through direct method call, it did not return control to the caller until the requested execution was completed. This behavior can be changed, so that execute() returns immediately, while, in fact, it keeps on running in a separate thread. This paragraph explains how this behavior can be achieved as well as warns about the dangers associated with asynchronous execution.
Asynchronous execution can be invoked on any statement, through the direct call to executeAsync() method. This method returns a const reference to Statement::Result. This reference can be used at a later time to ensure completion of the background execution and, for those statements that return rows, find out how many rows were retrieved.
Here's the code:
Statement stmt = (ses << "SELECT (firstname, lastname, age) FROM Person", into(firstName), into(lastName), into(age)); Statement::Result result = stmt.executeAsync(); // ... do something else Statement::ResultType rows = result.wait();
The above code did not do anything "under the hood" to change the statement's nature. If we call execute() afterwards, it will execute synchronously as usual. There is, however, a way (or two) to turn the statement into asynchronous mode permanently.
First, there is an explicit setAync() call:
Statement stmt = (ses << "SELECT (age) FROM Person", into(age)); stmt.setAsync(true); // make stmt asynchronous stmt.execute(); // executes asynchronously // ... do something else Statement::ResultType rows = stmt.wait(); // synchronize and retrieve the number of rows
And, then, there is also the async manipulator that has the same effect as the setAync(true) code above:
Statement stmt = (ses << "SELECT (age) FROM Person", into(age), async); // asynchronous statement stmt.execute(); // executes asynchronously // ... do something else Statement::ResultType rows = stmt.wait();
Note
In the first example, we have received Result from the statement, while in the second two, we did not assign the return value from execute(). The Result returned from executeAsync() is also known as future — a variable holding a result that will be known at some point in future. The reason for not keeping the execute() return value is because, for asynchronous statements, execute() always returns zero. This makes sense, because it does not know the number of returned rows (remember, asynchronous execute() call returns immediately and does not wait for the completion of the execution).
A Word of Warning
With power comes responsibility. When executing asynchronously, make sure to synchronize accordingly. When you fail to synchronize explicitly, you may encounter all kinds of funny things happening. Statement does internally try to protect you from harm, so the following code will usually throw InvalidAccessException:
Statement stmt = (ses << "SELECT (age) FROM Person", into(age), async); // asynchronous statement Statement::Result result = stmt.execute(); // executes asynchronously stmt.execute(); // throws InvalidAccessException
We say "usually", because it may not happen every time, depending whether the first execute() call completed in the background prior to calling the second one. Therefore, to avoid unpleasant surprises, it is highly recommended to always call wait() on either the statement itself or the result (value returned from executeAsync()) prior to engaging into a next attempt to execute.
Things NOT To Do
The use keyword expects as input a reference parameter, which is bound later during execution. Thus, one should never pass temporaries to use():
Statement stmt = (ses << "INSERT INTO PERSON VALUES (?, ?, ?)", use(getForename()), use(getSurname()), use(getAge())); //!!! // do something else stmt.execute(); // oops!
It is possible to use bind() instead of use(). The bind() call will always create a copy of the supplied argument. Also, it is possible to execute a statement returning data without supplying the storage and have the statement itself store the returned data for later retrieval through RecordSet. For details, see RecordSet chapter.
Things TO Do
Constants, as well as naked variables (of POD and std::string types) are permitted in the comma-separated list passed to statement. The following example is valid:
std::string fname = "Bart"; std::string lname = "Simpson"; int age = 42; Statement stmt = (ses << "INSERT INTO %s VALUES (?, ?, %d)", "PERSON", use(fname), use(lname), 12); stmt.execute();
Placeholders for values are very similar (but not identical) to standard printf family of functions. For details refer to Poco::format() documentation. Note: If you are alarmed by mention of printf(), a well-known source of many security problems in C and C++ code, do not worry. Poco::format() family of functions is safe (and, admittedly, slower than printf).
For cases where this type of formatting is used with queries containing the percent sign, use double percent ("%%"):
Statement stmt = (ses << "SELECT * FROM %s WHERE Name LIKE 'Simp%%'", "Person"); stmt.execute();
yields the following SQL statement string:
SELECT * FROM Person WHERE Name LIKE 'Simp%'
STL Containers
To handle many values at once, which is a very common scenario in database access, STL containers are used.
The framework supports the following container types out-of-the-box:
- deque: no requirements
- vector: no requirements
- list: no requirements
- set: the < operator must be supported by the contained datatype. Note that duplicate key/value pairs are ignored.
- multiset: the < operator must be supported by the contained datatype
- map: the () operator must be supported by the contained datatype and return the key of the object. Note that duplicate key/value pairs are ignored.
- multimap: the () operator must be supported by the contained datatype and return the key of the object
A "one-at-atime" bulk insert example via vector would be:
std::string aName; std::vector<std::string> data; for (int i = 0; i < 100; ++i) { aName.append("x"); data.push_back(aName); } ses << "INSERT INTO FORENAME VALUES(?)", use(data), now;
The same example would work with list, deque, set or multiset but not with map and multimap (std::string has no () operator).
Note that use requires a non-empty container!
Now reconsider the following example:
std::string aName; ses << "SELECT NAME FROM FORENAME", into(aName), now;
Previously, it worked because the table contained only one single entry but now the database table contains at least 100 strings, yet we only offer storage space for one single result.
Thus, the above code will fail and throw an exception.
One possible way to handle this is:
std::vector<std::string> names; ses << "SELECT NAME FROM FORENAME", into(names), now;
And again, instead of vector, one could use deque, list, set or multiset.
Things NOT To Do
C++ containers in conjunction with stored procedures input parameters (i.e in and io functions) are not supported. Furthermore, there is one particular container which, due to its peculiar nature, can not be used in conjunction with out and io under any circumstances: std::vector<bool> . The details are beyond the scope of this manual. For those interested to learn more about it, there is an excellent explanation in S. Meyers book "Efective STL", Item 18 or Gotw #50, When Is a Container Not a Container]] paragraph.
Tuples
Complex user-defined data types are supported through type handlers as described in one of the chapters below. However, in addition to STL containers, which are supported through binding/extraction there is another complex data type supported by POCO Data "out-of-the-box". The type is Poco::Tuple. The detailed description is beyond the scope of this manual, but suffice it to say here that this data structure allows for convenient and type-safe mix of different data types resulting in a perfect C++ match for the table row. Here's the code to clarify the point:
typedef Poco::Tuple<std::string, std::string, int> Person; Person person("Bart Simpson", "Springfield", 12) session << "INSERT INTO Person VALUES(?, ?, ?)", use(person), now;
Automagically, POCO Data internally takes care of the data binding intricacies for you. Of course, as before, it is programmer's responsibility to make sure the Tuple data types correspond to the table column data types.
I can already see the reader wondering if it's possible to put tuples in a container and kill more than one bird with one stone. As usual, POCO Data will not disappoint you:
typedef Poco::Tuple<std::string, std::string, int> Person; typedef std::vector<Person> People; People people; people.push_back(Person("Bart Simpson", "Springfield", 12)); people.push_back(Person("Lisa Simpson", "Springfield", 10)); session << "INSERT INTO Person VALUES(?, ?, ?)", use(people), now;
And thats it! There are multiple columns and multiple rows contained in a single variable and inserted in one shot. Needless to say, the reverse works as well:
session << "SELECT Name, Address, Age FROM Person", into(people), now;
Limits and Ranges
Limit
Working with collections might be convenient to bulk process data but there is also the risk that large operations will block your application for a very long time. In addition, you might want to have better fine-grained control over your query, e.g. you only want to extract a subset of data until a condition is met.
To alleviate that problem, one can use the limit keyword.
Let's assume we are retrieving thousands of rows from a database to render the data to a GUI. To allow the user to stop fetching data any time (and to avoid having the user frantically click inside the GUI because it doesn't show anything for seconds), we have to partition this process:
std::vector<std::string> names; ses << "SELECT NAME FROM FORENAME", into(names), limit(50), now;
The above example will retrieve up to 50 rows from the database (note that returning nothing is valid!) and append it to the names collection, i.e. the collection is not cleared!
If one wants to make sure that exactly 50 rows are returned one must set the second limit parameter (which per default is set to false) to true:
std::vector<std::string> names; ses << "SELECT NAME FROM FORENAME", into(names), limit(50, true), now;
Iterating over a complete result collection is done via the Statement object until statement.done() returns true.
For the next example, we assume that our system knows about 101 forenames:
std::vector<std::string> names; Statement stmt = (ses << "SELECT NAME FROM FORENAME", into(names), limit(50)); stmt.execute(); //names.size() == 50 poco_assert (!stmt.done()); stmt.execute(); //names.size() == 100 poco_assert (!stmt.done()); stmt.execute(); //names.size() == 101 poco_assert (stmt.done());
We previously stated that if no data is returned this is valid too. Thus, executing the following statement on an empty database table will work:
std::string aName; ses << "SELECT NAME FROM FORENAME", into(aName), now;
To guarantee that at least one valid result row is returned use the lowerLimit clause:
std::string aName; ses << "SELECT NAME FROM FORENAME", into(aName), lowerLimit(1), now;
If the table is now empty, an exception will be thrown. If the query succeeds, aName is guaranteed to be initialized. Note that limit is only the short name for upperLimit. To iterate over a result set step-by-step, e.g. one wants to avoid using a collection class, one would write
std::string aName; Statement stmt = (ses << "SELECT NAME FROM FORENAME", into(aName), lowerLimit(1), upperLimit(1)); while (!stmt.done()) stmt.execute();
Range
For the lazy folks, there is the range command:
std::string aName; Statement stmt = (ses << "SELECT NAME FROM FORENAME", into(aName), range(1,1)); while (!stmt.done()) stmt.execute();
The third parameter to range is an optional boolean value which specifies if the upper limit is a hard limit, ie. if the amount of rows returned by the query must match exactly. Per default exact matching is off.
Bulk
The bulk keyword allows to boost performance for the connectors that support column-wise operation and arrays of values and/or parameters (e.g. ODBC). Here's how to signal bulk insertion to the statement:
std::vector<int> ints(100, 1); session << "INSERT INTO Test VALUES (?)", use(ints, bulk), now;
The above code will execute a "one-shot" insertion into the target table.
Selection in bulk mode looks like this:
std::vector<int> ints; session << "SELECT * FROM Test", into(ints, bulk(100)), now;
Note that, when fetching data in bulk quantities, we must provide the size of data set we want to fetch, either explicitly as in the code above or implicitly, through size of the supplied container as in following example:
std::vector<int> ints(100, 1); session << "SELECT * FROM Test", into(ints, bulk), now;
For statements that generate their ow internal extraction storage (see RecordSet chapter below), bulk execution can be specified as follows:
session << "SELECT * FROM Test", bulk(100), now;
Usage Notes
When using bulk mode, execution limit is set internally. Mixing of bulk and limit keywords, although redundant, is allowed as long as they do not conflict in the value they specify.
Bulk operations are only supported for following STL containers:
- std::deque
- std::list
- std::vector, including std::vector<bool>, which is properly handled internally
For best results with use(), when passing POD types, it is recommended to use std::vector as it is passed directly as supplied by the user. For all the other scenarios (other containers as well as non-POD types), framework will create temporary storage.
Data types supported are:
- All POD types
- std::string
- Poco::Data::LOB (with BLOB and CLOB specializations)
- Poco::DateTime
- Poco::Data::Date
- Poco::Data::Time
- Poco::Dynamic::Var
Important Considerations
Not all the connectors support bulk and some support it only to an extent, depending on the target system. Also, not all value types perform equally when used for bulk operations. To determine the optimal use in a given scenario, knowledge of the target system as well as some degree of experimentation is needed because different connectors and target systems shall differ in performance gains. In some scenarios, the gain is significant. For example, Oracle ODBC driver performs roughly 400-500 times faster when bulk-inserting a std::vector of 10,000 integers. However, when variable-sized entities, such as strings and BLOBs are brought into the picture, performance decreases drastically. So, all said, it is left to the end-user to make the best of this feature.
RecordSets, Iterators and Rows
In all the examples so far the programmer had to supply the storage for data to be inserted or retrieved from a database.
It is usually desirable to avoid that and let the framework take care of it, something like this:
session << "SELECT * FROM Person", now; // note the absence of target storage
No worries — that's what the RecordSet class does:
Statement select(session); // we need a Statement for later RecordSet creation select << "SELECT * FROM Person", now; // create a RecordSet RecordSet rs(select); std::size_t cols = rs.columnCount(); // print all column names for (std::size_t col = 0; col < cols; ++col) std::cout << rs.columnName(col) << std::endl; // iterate over all rows and columns for (RecordSet::Iterator it = rs.begin(); it != rs.end(); ++it) std::cout << *it << " ";
As you may see above, RecordSet class comes with a full-blown C++ compatible iterator that allows the above loop to be turned into a one-liner:
std::copy(rs.begin(), rs.end(), std::ostream_iterator<Row>(std::cout));
RecordSet has the stream operator defined, so this shortcut to the above functionality will work, too:
std::cout << rs;
The default formatter supplied with RecordSet is quite rudimentary, but user can implement custom formatters, by inheriting from RowFormatter and providing definitions of formatNames() and formatValues() virtual functions. See the RowFormatter sample for details on how to accomplish this.
You'll notice the Row class in the above snippet. The RecordSet::Iterator is actually a Poco::Data::RowIterator. It means that dereferencing it returns a Poco::Data::Row object. Here's a brief example to get an idea of what the Poco::Data::Row class does:
Row row; row.append("Field0", 0); row.append("Field1", 1); row.append("Field2", 2);
The above code creates a row with three fields, "Field0", "Field1" and "Field2", having values 0, 1 and 2, respectively. Rows are sortable, which makes them suitable to be contained by standard sorted containers, such as std::map or std::set. By default, the first field of the row is used for sorting purposes. However, the sort criteria can be modified at runtime. For example, an additional field may be added to sort fields (think "... ORDER BY Name ASC, Age DESC"):
row.addSortField("Field1"); // now Field0 and Field1 are used for sorting row.replaceSortField("Field0", "Field2");// now Field1 and Field2 are used for sorting
Finally, if you have a need for different RecordSet internal storage type than default (std::deque) provided by framework, there is a manipulator for that purpose:
select << "SELECT * FROM Person", list, now; // use std::list as internal storage container
This can be very useful if you plan to manipulate the data after retrieving it from database. For example, std::list performs much better than std::vector for insert/delete operations and specifying it up-front as internal storage saves you the copying effort later. For large datasets, performance savings are significant.
Valid storage type manipulators are:
- deque (default)
- vector
- list
So, if neither data storage, nor storage type are explicitly specified, the data will internally be kept in standard deques. This can be changed through use of storage type manipulators.
Complex Data Types
All the previous examples were contented to work with only the most basic data types: integer, string, ... a situation, unlikely to occur in real-world scenarios.
Assume you have a class Person:
class Person { public: // default constructor+destr. // getter and setter methods for all members // ... bool operator <(const Person& p) const /// we need this for set and multiset support { return _socialSecNr < p._socialSecNr; } Poco::UInt64 operator()() const /// we need this operator to return the key for the map and multimap { return _socialSecNr; } private: std::string _firstName; std::string _lastName; Poco::UInt64 _socialSecNr; };
Ideally, one would like to use a Person as simple as one used a string. All that is needed is a template specialization of the TypeHandler template. Note that template specializations must be declared in the same namespace as the original template, i.e. Poco::Data. The template specialization must implement the following methods:
namespace Poco { namespace Data { template <> class TypeHandler<class Person> { public: static void bind(std::size_t pos, const Person& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir) { poco_assert_dbg (!pBinder.isNull()); // the table is defined as Person (FirstName VARCHAR(30), lastName VARCHAR, SocialSecNr INTEGER(3)) // Note that we advance pos by the number of columns the datatype uses! For string/int this is one. TypeHandler<std::string>::bind(pos++, obj.getFirstName(), pBinder, dir); TypeHandler<std::string>::bind(pos++, obj.getLastName(), pBinder, dir); TypeHandler<Poco::UInt64>::bind(pos++, obj.getSocialSecNr(), pBinder, dir); } static std::size_t size() { return 3; // we handle three columns of the Table! } static void prepare(std::size_t pos, const Person& obj, AbstractPreparator::Ptr pPrepare) { poco_assert_dbg (!pPrepare.isNull()); // the table is defined as Person (FirstName VARCHAR(30), lastName VARCHAR, SocialSecNr INTEGER(3)) // Note that we advance pos by the number of columns the datatype uses! For string/int this is one. TypeHandler<std::string>::prepare(pos++, obj.getFirstName(), pPrepare); TypeHandler<std::string>::prepare(pos++, obj.getLastName(), pPrepare); TypeHandler<Poco::UInt64>::prepare(pos++, obj.getSocialSecNr(), pPrepare); } static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor::Ptr pExt) /// obj will contain the result, defVal contains values we should use when one column is NULL { poco_assert_dbg (!pExt.isNull()); std::string firstName; std::string lastName; Poco::UInt64 socialSecNr = 0; TypeHandler<std::string>::extract(pos++, firstName, defVal.getFirstName(), pExt); TypeHandler<std::string>::extract(pos++, lastName, defVal.getLastName(), pExt); TypeHandler<Poco::UInt64>::extract(pos++, socialSecNr, defVal.getSocialSecNr(), pExt); obj.setFirstName(firstName); obj.setLastName(lastName); obj.setSocialSecNr(socialSecNr); } private: TypeHandler(); ~TypeHandler(); TypeHandler(const TypeHandler&); TypeHandler& operator=(const TypeHandler&); }; } } // namespace Poco::Data
And that's all you have to do. Working with Person is now as simple as working with a string:
std::map<Poco::UInt64, Person> people; ses << "SELECT * FROM Person", into(people), now;
Session Pooling
Creating a connection to a database is often a time consuming operation. Therefore it makes sense to save a session object for later reuse once it is no longer needed.
A Poco::Data::SessionPool manages a collection of sessions. When a session is requested, the SessionPool first looks in its set of already initialized sessions for an available object. If one is found, it is returned to the client and marked as "in-use". If no session is available, the SessionPool attempts to create a new one for the client. To avoid excessive creation of sessions, a limit can be set on the maximum number of objects.
The following code fragment shows how to use the SessionPool:
SessionPool pool("ODBC", "..."); // ... Session sess(pool.get());
Pooled sessions are automatically returned to the pool when the Session variable holding them is destroyed.
One session pool, of course, holds sessions for one database connection. For sessions to multiple databases, there is SessionPoolContainer:
SessionPoolContainer spc; AutoPtr<SessionPool> pPool1 = new SessionPool("ODBC", "DSN1"); AutoPtr<SessionPool> pPool2 = new SessionPool("ODBC", "DSN2"); spc.add(pPool1); spc.add(pPool2);
Conclusion
This document provides an overview of the most important features offered by the POCO Data framework. The framework also supports LOB (specialized to BLOB and CLOB) type as well as Poco::DateTime binding. The usage of these data types is no different than any C++ type, so we did not go into details here.
The great deal of RecordSet and Row runtime "magic" is achieved through employment of Poco::Dynamic::Var, which is the POCO equivalent of dynamic language data type. Obviously, due to its nature, there is a run time performance penalty associated with Poco::Dynamic::Var, but the internal details are beyond the scope of this document.
POCO Data tries to provide a broad spectrum of functionality, with configurable efficiency/convenience ratio, providing a solid foundation for quick development of database applications. We hope that, by reading this manual and experimenting with code along the way, you were able to get a solid understanding of the framework. We look forward to hearing from you about POCO Data as well as this manual. We also hope that you find both to be helpful aid in design of elegant and efficient standard C++ database access software.


E-40 Reps The 49ers With A Passion On "Niner Gang"
E-40 is back with an anthem for the San Francisco 49ers.
by Aron A.Niner Gang
E-40
Editor Rating: HOTTTTT
User Rating: very hottttt - 100% (1)
When it comes to Bay Area sports, E-40 is undoubtedly one of the most devoted fans, especially when it comes to football and basketball. We saw him at the NBA Finals this year when the Toronto Raptors took down the Golden State Warriors for the championships. Although he didn't release a song for the occasion, he's clearly not letting any time pass during the NFL season.
E-40 teamed up with Droop-E for a hyphy banger for the 49ers. "Niner Gang" is an appropriate anthem considering the 9ers performance this year. They're currently 8-0 and 40 is making sure that everyone in San Francisco and the Bay Area are representing the team. "I tried to told em we back & we never left and we got a heart, Levi stadium starting to feel like candlestick Park!" he wrote on Instagram.
Quotable Lyrics
Against all odds, weather the storm
Built for combat and battle, young hyenas in uniform
We play no games with the opposition, we active
Let the whistle be the bell, we gon' get down what we mad at


Credits:
Oussama Mubarak
. January 2018.
Created in the context of his thesis project,
Designing and Modeling Collective Co-located Interactions for Art Installations
conducted at
Cédric
and
EnsadLab
.


Classes in Session
Learn those scales!
02014-11-30
So one of the defining features of Ruby as a language is that it is object oriented. This means all of its operations are somehow construted as objects interacting with each other. This is a useful design paradigm for programs that might be used in unexpected or very broad ways. You can capture intended uses into just the methods that exist.
I have included a simple example of a class of objects. It crudely models the behavior of a guitar fretboard. It can be found here. At the moment it has two major functionalities, drawing on major scales, and printing out the result. The class is initiated by calling object1 = FretBoard.new() and from there you can print an adorned board. But maybe you'd like to see what frets are associated with the c-major scale, you could call object1.place_scale("c",0). This would prime the board so it's marked with the notes for the c-major scale, and we could see it when we print it with object1.print_kneck.
This is nice, but maybe we want to compare the c scale, to d-sharp? well, sharps are noted with capitals. So we could make a second scale, object2= Fretboard.new(), object2.place_scale("D",0) and object2.print_kneck. Now it's printed out a seperate instance of the kneck. This is handy because we've stored two different states of a similar thing. This is part of the purpose of objects, is that they all fit in some broad category, but are variations of each other.


public class Controller
extends java.lang.Object
The Controller
class updates and receives events from the view.
Furthermore it manipulates the model and handles the settings.
| Modifier and Type | Field and Description |
|---|---|
private java.util.List<Configuration> |
config |
static int |
CONFIGURATION_TO_MODEL |
static int |
CONFIGURATION_TO_VIEW |
static int |
DUPLICATE |
private java.lang.String[] |
errorMsgs |
static int |
FORCE_UPDATE |
static int |
LOAD |
static int |
MENUBAR |
private Model |
model |
static int |
NEW |
static int |
RADIATOR_UPDATE |
static int |
RESET |
private Settings |
settings |
private int |
simIndex |
private int |
simNameIndex |
static int |
TOOLBAR |
static int |
UPDATE |
private View |
view |
static int |
VIEW_TO_CONFIGURATION |
| Constructor and Description |
|---|
Controller(Model model,
View view) |
| Modifier and Type | Method and Description |
|---|---|
void |
addRadiator(double x,
double y)
If the radiator count is not 100 already:
- Calls the corresponding method to add a new radiator
- Calls the corresponding method to convert the geometry to 'Custom'
- Calls the corresponding method to update the simulation
|
void |
antennaLobeEnforcer(double[] config)
Enforces the main lobe angle and/or the side lobe attenuation by calling the method calcRadiatorsPhase() and/or applyWindowFunction().
|
void |
applyWindowFunction(double[] config)
Calls the corresponding method to apply a window function to all the amplitudes of a linear array.
|
void |
calcRadiatorsPhase(double[] config)
Calls the corresponding method to calculate the phases of all the radiators in a linear array.
|
int |
checkForChanges(double[] config)
Checks the input values for changes.
|
int |
configAuditor(double[] config)
Validates all the config values.
|
void |
convertToCustom()
Converts the geometry to 'Custom' without resetting all the radiators nor triggering an event.
|
void |
copyDiagram()
Copies the diagram of the currently selected simulation to the clipboard.
|
void |
createSimulation(int condition,
java.lang.String name,
double[][] radiatorParameters)
Creates a new SimPanel object, fills all the fields accordingly and adds the new object to the SimTabbedPane.
|
void |
deleteSimulation()
Deletes the currently selected simulation.
|
void |
disableAntennaLobe()
Disables the main lobe angle and the side lobe attenuation without triggering an event.
|
void |
displayError(java.lang.String errorMsg)
Calls the corresponding method to display an error message on the status bar.
|
void |
displayMsg(java.lang.String message)
Calls the corresponding method to display a message on the status bar.
|
int |
getAngularUnit()
Returns the angular unit.
|
double[] |
getConfig(int arrayIndex)
Returns the configuration array at the arrayIndex position.
|
int |
getElectromagneticRadiationUnit()
Returns the electromagnetic radiation unit.
|
double[] |
getInputValues()
Gets the values of all input elements of the currently selected simulation.
|
java.lang.String |
getName(int arrayIndex)
Returns the name of the simulation at the arrayIndex position.
|
void |
loadSimulation(java.lang.String content)
Validates the content of a loaded simulation (*.csv file).
|
void |
newSimulation(int condition,
java.lang.String name,
double[][] radiatorParameters,
double[] config)
Initializes a new simulation by,
- creating a new Configuration object with default parameters or
- duplicating an existing Configuration object or
- creating a new Configuration object by using the configuration parameters from a loaded file.
|
int |
reflectorAuditor(double[] config)
Checks if the reflector is placed on top of a radiator.
|
void |
removeRadiators(int[] radiatorIndices)
- Calls the corresponding method to remove the radiators at the given indices
- Calls the corresponding method to convert the geometry to 'Custom'
- Calls the corresponding method to update the simulation
|
void |
renameSimulation(java.lang.String name)
Renames the selected simulation.
|
void |
resetStatusBar()
Calls the corresponding method to clear the displayed message/error on the status bar.
|
java.lang.String |
saveSimulation()
Prepares the parameters of the currently selected simulation to be saved in a *.csv file.
|
void |
setElectromagneticRadiationUnit(int source,
int electromagneticRadiationUnit)
Compares the electromagnetic radiation unit from the Settings class to the one supplied to the method.
|
void |
setInputValues(int simIndex)
Sets all input elements of a given simulation to the according values stored in the configuration object with the given simIndex.
|
void |
setRadiatorsState(int[] radiatorIndices,
boolean state)
- Calls the corresponding method to set the 'hidden' state of the radiators at the given indices
- Calls the corresponding method to update the simulation
|
void |
setSimIndex(int simIndex)
Sets the field simIdex to the index of the currently selected tab.
|
void |
settingsChanged(int electromagneticRadiationUnit)
Changes the necessary input fields by calling the corresponding method in the PropertiesPanel class for each simulation.
|
double[] |
settingsEnforcer(int direction,
double[] config)
Enforces the settings to a supplied configuration array.
|
void |
updatePeriod(double[] config)
Calls the corresponding method to update the period.
|
void |
updateRadiatorPosition(int radiatorIndex,
double x,
double y)
- Calls the corresponding method to update the radiators position
- Calls the corresponding method to convert the geometry to 'Custom'
- Calls the corresponding method to update the simulation
|
void |
updateRadiatorsAmplitude(int[] radiatorIndices,
double a)
- Calls the corresponding method to update the amplitude of the radiators at the given indices
- Calls the corresponding method to update the simulation
|
void |
updateRadiatorsPhase(int[] radiatorIndices,
double p)
- Calls the corresponding method to update the phase of the radiators at the given indices
- Calls the corresponding method to update the simulation
|
void |
updateSimulation(int condition)
Gets the values from all the input fields and checks if there were any changes.
|
private Model model
private View view
private java.util.List<Configuration> config
private Settings settings
private int simIndex
private int simNameIndex
private java.lang.String[] errorMsgs
public static final int NEW
public static final int DUPLICATE
public static final int LOAD
public static final int UPDATE
public static final int RESET
public static final int RADIATOR_UPDATE
public static final int FORCE_UPDATE
public static final int MENUBAR
public static final int TOOLBAR
public static final int CONFIGURATION_TO_MODEL
public static final int CONFIGURATION_TO_VIEW
public static final int VIEW_TO_CONFIGURATION
public void newSimulation(int condition, java.lang.String name, double[][] radiatorParameters, double[] config)
Initializes a new simulation by, - creating a new Configuration object with default parameters or - duplicating an existing Configuration object or - creating a new Configuration object by using the configuration parameters from a loaded file. Calls the corresponding method to create the simulation.
condition
- name
- used when a simulation is loaded from a fileradiatorParameters
- used when a simulation is loaded from a fileconfig
- used when a simulation is loaded from a filepublic void createSimulation(int condition, java.lang.String name, double[][] radiatorParameters)
Creates a new SimPanel object, fills all the fields accordingly and adds the new object to the SimTabbedPane. Creates the diagram and notifies the observers.
condition
- name
- radiatorParameters
- used when a simulation is loaded from a filepublic void deleteSimulation()
Deletes the currently selected simulation. Creates a new simulation, if it was the last simulation.
public void renameSimulation(java.lang.String name)
Renames the selected simulation.
name
- public void updateSimulation(int condition)
Gets the values from all the input fields and checks if there were any changes. If the input values have changed and they are valid: - Resets error messages - Updates the diagram and notifies the observers - Warns if one ore more radiators were placed on top of the reflector
condition
- public void setSimIndex(int simIndex)
Sets the field simIdex to the index of the currently selected tab.
simIndex
- public void setElectromagneticRadiationUnit(int source, int electromagneticRadiationUnit)
Compares the electromagnetic radiation unit from the Settings class to the one supplied to the method. If they are different: - Calls the corresponding method to set the electromagnetic radiation unit in the Settings class - Calls the method settingsChanged() to update the view - If the source is the toolbar: - Change the selection in the menu bar
source
- either the menu bar or the toolbarelectromagneticRadiationUnit
- public void settingsChanged(int electromagneticRadiationUnit)
Changes the necessary input fields by calling the corresponding method in the PropertiesPanel class for each simulation.
electromagneticRadiationUnit
- public int getAngularUnit()
Returns the angular unit.
public int getElectromagneticRadiationUnit()
Returns the electromagnetic radiation unit.
public double[] settingsEnforcer(int direction, double[] config)
Enforces the settings to a supplied configuration array.
direction
- the direction to enforce the settingsconfig
- public void setInputValues(int simIndex)
Sets all input elements of a given simulation to the according values stored in the configuration object with the given simIndex.
simIndex
- public double[] getInputValues()
Gets the values of all input elements of the currently selected simulation. Returns a cofig array containing all the configuration values.
public int configAuditor(double[] config)
Validates all the config values.
config
- the configuration array to be validatedpublic int reflectorAuditor(double[] config)
Checks if the reflector is placed on top of a radiator.
config
- public double[] getConfig(int arrayIndex)
Returns the configuration array at the arrayIndex position.
arrayIndex
- public java.lang.String getName(int arrayIndex)
Returns the name of the simulation at the arrayIndex position.
arrayIndex
- public void loadSimulation(java.lang.String content)
Validates the content of a loaded simulation (*.csv file). If the content is valid: - Calls the corresponding method to initialize a new simulation - Displays a message in the status bar
content
- the content from the loaded *.csv filepublic java.lang.String saveSimulation()
Prepares the parameters of the currently selected simulation to be saved in a *.csv file. Returns the content properly formatted to be saved in a *.csv file.
public void copyDiagram()
Copies the diagram of the currently selected simulation to the clipboard.
public void addRadiator(double x, double y)
If the radiator count is not 100 already: - Calls the corresponding method to add a new radiator - Calls the corresponding method to convert the geometry to 'Custom' - Calls the corresponding method to update the simulation
x
- the x-value of the positiony
- the y-value of the positionpublic void removeRadiators(int[] radiatorIndices)
- Calls the corresponding method to remove the radiators at the given indices - Calls the corresponding method to convert the geometry to 'Custom' - Calls the corresponding method to update the simulation
radiatorIndices
- an array containing the radiator indices to be removedpublic void updateRadiatorPosition(int radiatorIndex, double x, double y)
- Calls the corresponding method to update the radiators position - Calls the corresponding method to convert the geometry to 'Custom' - Calls the corresponding method to update the simulation
radiatorIndex
- the index of the radiator to be relocatedx
- the new x-value of the positiony
- the new y-value of the positionpublic void setRadiatorsState(int[] radiatorIndices, boolean state)
- Calls the corresponding method to set the 'hidden' state of the radiators at the given indices - Calls the corresponding method to update the simulation
radiatorIndices
- an array containing the radiator indices to be changedstate
- the 'hidden' statepublic void updateRadiatorsPhase(int[] radiatorIndices, double p)
- Calls the corresponding method to update the phase of the radiators at the given indices - Calls the corresponding method to update the simulation
radiatorIndices
- an array containing the radiator indices to be changedp
- the new value of the phasepublic void updateRadiatorsAmplitude(int[] radiatorIndices, double a)
- Calls the corresponding method to update the amplitude of the radiators at the given indices - Calls the corresponding method to update the simulation
radiatorIndices
- an array containing the radiator indices to be changeda
- the new value of the amplitudepublic void updatePeriod(double[] config)
Calls the corresponding method to update the period.
config
- the config array containing the new periodpublic void calcRadiatorsPhase(double[] config)
Calls the corresponding method to calculate the phases of all the radiators in a linear array.
config
- the config array containing the main lobe anglepublic void applyWindowFunction(double[] config)
Calls the corresponding method to apply a window function to all the amplitudes of a linear array.
config
- the config array containing the window function and its parameterpublic void antennaLobeEnforcer(double[] config)
Enforces the main lobe angle and/or the side lobe attenuation by calling the method calcRadiatorsPhase() and/or applyWindowFunction().
config
- public void disableAntennaLobe()
Disables the main lobe angle and the side lobe attenuation without triggering an event.
public void convertToCustom()
Converts the geometry to 'Custom' without resetting all the radiators nor triggering an event.
public int checkForChanges(double[] config)
Checks the input values for changes.
config
- the read in values from the uipublic void displayError(java.lang.String errorMsg)
Calls the corresponding method to display an error message on the status bar.
errorMsg
- the message to be displayedpublic void displayMsg(java.lang.String message)
Calls the corresponding method to display a message on the status bar.
message
- the message to be displayedpublic void resetStatusBar()
Calls the corresponding method to clear the displayed message/error on the status bar.


public class MinimumClearance
extends java.lang.Object
Geometry
.
The Minimum Clearance is a measure of what magnitude of perturbation of the vertices of a geometry can be tolerated before the geometry becomes topologically invalid. The smaller the Minimum Clearance distance, the less vertex pertubation the geometry can tolerate before becoming invalid.
The concept was introduced by Thompson and Van Oosterom [TV06], based on earlier work by Milenkovic [Mi88].
The Minimum Clearance of a geometry G is defined to be the value r such that "the movement of all points by a distance of r in any direction will guarantee to leave the geometry valid" [TV06]. An equivalent constructive definition [Mi88] is that r is the largest value such:
If G has only a single vertex (i.e. is a
Point
), the value of the minimum clearance
is Double.MAX_VALUE
.
If G is a Puntal
or Lineal
geometry,
then in fact no amount of perturbation
will render the geometry invalid.
In this case a Minimum Clearance is still computed
based on the vertex and segment distances
according to the constructive definition.
It is possible for no Minimum Clearance to exist.
For instance, a MultiPoint
with all members identical
has no Minimum Clearance
(i.e. no amount of perturbation will cause
the member points to become non-identical).
Empty geometries also have no such distance.
The lack of a meaningful MinimumClearance distance is detected
and suitable values are returned by
getDistance()
and getLine()
.
The computation of Minimum Clearance utilizes
the STRtree.nearestNeighbour(ItemDistance)
method to provide good performance even for
large inputs.
An interesting note is that for the case of MultiPoint
s,
the computed Minimum Clearance line
effectively determines the Nearest Neighbours in the collection.
| Constructor and Description |
|---|
MinimumClearance(Geometry geom)
Creates an object to compute the Minimum Clearance
for the given Geometry
|
| Modifier and Type | Method and Description |
|---|---|
double |
getDistance()
Gets the Minimum Clearance distance.
|
static double |
getDistance(Geometry g)
Computes the Minimum Clearance distance for
the given Geometry.
|
LineString |
getLine()
Gets a LineString containing two points
which are at the Minimum Clearance distance.
|
static Geometry |
getLine(Geometry g)
Gets a LineString containing two points
which are at the Minimum Clearance distance
for the given Geometry.
|
public MinimumClearance(Geometry geom)
geom
- the input geometrypublic static double getDistance(Geometry g)
g
- the input geometrypublic static Geometry getLine(Geometry g)
g
- the input geometrypublic double getDistance()
If no distance exists (e.g. in the case of two identical points) Double.MAX_VALUE is returned.
public LineString getLine()
If no distance could be found (e.g. in the case of two identical points) LINESTRING EMPTY is returned.


Union enjoying reputation as Bundesliga giant-killers
by Agency ReportGoal-scorers Anthony Ujah and Sebastian Andersson say mid-table FC Union are happy forging a reputation as Bundesliga giant-killers after adding Borussia Moenchengladbach to their growing list of big name victims.
Having already stunned Borussia Dortmund and Freiburg at their Alten Foersterei stadium in only their first season in Germany’s top flight, Union also shocked Gladbach 2-0 on Saturday in Berlin.
It is the second time this season Union have beaten the Bundesliga’s leading side after also pulling off a 3-1 win in late August over Dortmund, who then topped the table.
“I think so now, we have showed the big teams that we can win here,” said Andersson Swedish forward.
“We’re in a good mood, we won’t think too much about it, but we want to keep it going.”
Nigeria striker Ujah gave the hosts the lead in the 15th minutes with a well-taken header before Andersson also headed home deep into added time to give Union a fourth straight win.
Between them, Andersson and Ujah now have eight league goals this season.
Ujah agreed that Union are making a habit of raising their game at home, but warned that beating Gladbach will count for nothing when they travel to fourth-placed Schalke on Friday.
“We’re playing well and we want to make it hard for any opponent to beat us here,” said the 29-year-old.
“It feels good and we want to keep it going as long as possible, but we are just looking at each game as it comes.”
After their away game in Gelsenkirchen, mid-table Union face two teams in the bottom three when they host Cologne before facing Paderborn away.
“We are really happy with 16 points after 12 games and we’ve beaten the leaders, but it doesn’t mean it will be any easier to beat Cologne or Paderborn,” warned Ujah.
(AFP)


I'm a junior Computer Science and Economics double major at the University of Maryland, College Park. Go Terps!
I'm currently enrolled in the Advanced Cybersecurity Experience for Students (ACES) honors program. It's the first 4 year undergraduate cybersecurity program in the nation!
I'm a huge tennis geek! Chances are you'll be able to find me hitting on the courts with UMD's awesome club tennis team.
Goomba Squasher VR is a virtual reality Mario game built by integrating the Microsoft Kinect, Oculus Rift, and Unity game engine. The Kinect detects body movements which are translated into in-game actions for an immersive virtual reality experience
Clusterfy extracts songs from a user’s Spotify playlists and performs k-means clustering to group them based on fundamental features such as key signature and tempo. It recommends a playlist for each cluster and allows the user to insert it into their Spotify account
An Android app that interfaces with the Thalmic Myo to simulate a virtual drumset. Created at YHack
A web app that uses machine learning techniques to predict the outcome of tennis matches. Built with Python's scikit-learn library and Flask
Worked on backend of RITIS Filter Web Service which allows users to perform transportation related queries
Wrote R script that uses machine learning techniques to detect cyber attacks in web server log files
Worked on the backend of the Device Assist mobile app, which has a 4.2 rating on the Google Play Store with 100k-500k installs
I'll be working at Facebook's Menlo Park office!


surajit dutta
I'm a web devloper
About Me
I'm Surajit dutta and Web Developer
Hi! My name is Upvesh Kumar. I am a Web Developer, and I'm very passionate and dedicated to my work. With few years experience as a professional Web developer, I have acquired the skills and knowledge necessary to make your project a success. I enjoy every step of the design process, from discussion and collaboration.
Birthday : 25 march 1999
Age : 21
Email<EMAIL_ADDRESS>Degree : B.Tech
Mobile No : +91<PHONE_NUMBER>
City : Kolkata
Freelance : Available
Freelance : Available
UX/UI
Html
Css
javascript
wordpress
bootstrap
Education
2019 - 2021
B-tech in information technology
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque scelerisque diam non nisi semper, et elementum lorem ornare.
2019 - 2021
B-tech in information technology
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque scelerisque diam non nisi semper, et elementum lorem ornare.
2019 - 2021
B-tech in information technology
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque scelerisque diam non nisi semper, et elementum lorem ornare.
Experience
2019 - 2021
Backend Developer
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque scelerisque diam non nisi semper, et elementum lorem ornare.
2019 - 2021
Frontend Developer
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque scelerisque diam non nisi semper, et elementum lorem ornare.
2019 - 2021
Graphic Designer
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque scelerisque diam non nisi semper, et elementum lorem ornare.
Services
Web Design
Lorem Ipsum is simply dummy text of the printing and typesetting industry Lorem Ipsum.
Photography
Lorem Ipsum is simply dummy text of the printing and typesetting industry Lorem Ipsum.
Web Development
Lorem Ipsum is simply dummy text of the printing and typesetting industry Lorem Ipsum.
Video Editing
Lorem Ipsum is simply dummy text of the printing and typesetting industry Lorem Ipsum.
graphic designing
Lorem Ipsum is simply dummy text of the printing and typesetting industry Lorem Ipsum.
Logo Design
Lorem Ipsum is simply dummy text of the printing and typesetting industry Lorem Ipsum.
Portfolio
Web disgin
Web disgin
Wordpress
Photography
Web disgin
Wordpress
Letest blog
Responsive Web Design
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Dolore, porro rem quod illo quam, eum alias id, repellendus magni, quas.
Creative Slideshow
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Dolore, porro rem quod illo quam, eum alias id, repellendus magni, quas.
Gallery Lightbox
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Dolore, porro rem quod illo quam, eum alias id, repellendus magni, quas.
Contact Me
Call Us On
+91<PHONE_NUMBER>
Address
Kolkata
Bolder3255@gmail.com


While I still believe that the biggest single thing speaking for 3G is the need for more capacity, the general usefulness and features that people want to use are still of interest to many, including me. What will people really want to use?
<!– more –>
Nokia recently released a research report (link in German) that Nokia Networks conducted together with the HPI Research Group. In the report, they interviewed people or groups of people from different countries to see what these people really want to be using in the future. Keeping in mind that this is a Nokia report and that the video shown to these people to make them aware of what is possible, as well as the questions, might be a bit biased, it still shows that there is an interest there - which needs to be nurtured. What I just said regarding bias is not meant in a negative way but rather to point out that Nokia will obviously try to learn as best they can whether they are going in the right direction and what they should do in the future, hence a bias towards Nokia.
One thing that needs to be said at the start is that Nokia looked specifically at the core target for 3G offerings, including teenagers as well as young and family adults, as Nokia themselves put it. These groups are currently using mobile phones for personal purposes and are between 16 and 45 years old. 83% of the people surveyed believe technology makes life easier, 78% think the Internet and other devices are fun, while 76% are interested in new developments. Who would have thought.
One thing that clearly stands out in my mind, and not only so because it does in the graph in Nokia’s paper, is that 65% found the pace of change exciting. At the same time, the media is going on and on about how slowly the implementation of 3G is taking place - the financial press particularly so. I would judge that as a sign that people feel comfortable with the pace of change and don’t want things to move a lot faster. Some of us would of course like it (all who want cheap wireless broadband connectivity for their phones raise their hands), but the general public doesn’t want to get a new phone every month.
In light of a recent column of mine titled "I can do that?", I have to put an emphasis on my belief that the group used in the study is not representative. 86% know about SMS messages and 77% use it, which I find to be a lot. Even more, 83%, use the phone book. This is probably a telltale sign of the younger generation that has been surveyed for the research report, since when talking with older or less technology savvy people, I’ve noticed that very few of them use any of those features, and some don’t even use the phone book. Supporting my argument though, is that redirecting calls, call waiting, diary, calculator and games are used by less than 50% throughout the focus group. In short, Nokia has been talking to a technology savvy crowd.
If you look at the differences in how people from different countries respond when asked about their interest in new developments in the mobile phone arena, it’ll bring a smile to your face when you see that while 71% of Brazilian participants are very excited, only 26% of the UK participants, the homeland of Vodafone, are. As always, Germans are very wary of change, and while the participants are sure that new developments will change things a lot, Germany is in the back of the field when thinking that it will change things for the better. We Germans always assume the worse. :)
But who will buy these new phones or devices when they are out? 16% of the target audience want to have the first model that comes out, and 43% want one of these devices - though not the first one. This is a actually a large group of people that are sure that they want a 3G device. But will they pay for it? Actually, it seems as if the answer is yes, and I found it quite surprising when I read that 9% will pay a lot more for these mobile phones and a total of 60% will pay more.
This probably makes mobile phone manufacturers very happy as they will do their best to keep mobile phone prices up as high as they can. In general though, this sheds a positive light on the 3G market for the future.
So then, what will people want to do with these phones? Nokia asked the audience to name the features they would like to have available. To no surprise, SMS tops the list with 81%, some probably thinking rightfully so that this is a must have anyway. The list goes on with the use of Traffic/Weather Info (71%), Using a Camera (71%), Getting the latest headlines (67%), Sending photos to friends (64%), Video camera (63%), getting info on and booking movie and other kinds of tickets (both 62%) and lastly listening to the radio (60%).
After I looked through that list I found myself puzzled again. So, 59% would want to have a 3G device, even though maybe not the first one, but still over 60% want services from them that are available today on WAP phones - and have been available for some time now, far beyond the first poor implementations. I can easily check out the schedule at the nearest movie theatre, as well as news and weather info, and my mobile already helped me find a way around a traffic jam as well as told me the way to drive to reach a specific destination on several occasions.
The results for the rest of the features might be partly influenced by what kind of products Nokia already has or will have in its line-up. Nokia now includes radios in many models, and the reason for that is probably partly reflected in this research report. On top of that, adding a radio is fairly cheap and easy in mobile phones - not that it has anything to do with 3G as such, but it drives the multimedia paradigm. Using a camera and sending pictures is a really interesting feature though, and shows the way toward the Nokia 7650 as well as MMS. I personally would have put this high up there myself. Just imagine if you can easily - emphasis on easily - send pictures to your friends from wherever you are.
Judging from the report, it will probably be the simple things that will drive traffic for carriers, like more extensive WAP/Services usage and sending and receiving of pictures. Full motion video conferencing on your mobile phone might be interesting, but not everyone are willing to spend the huge amounts of money necessary to use that feature. All this will be driven forward in small steps with more and more multimedia capabilities being added to phones and people using those features once the prices to use them become attractive. This will drive new features to phones slowly, with a focus onfeatures that can be added without adding too much cost to the device as well as a focus on services that are not very bandwidth intensive since bandwidth, as always, costs money.
What this again proves is that both the handset makers and the carriers will have to move with full force towards showing users the ropes and how to use all these features in their phones. On top of that, I believe GPRS services prices will have to drop for people to start using GPRS intensively, although this might require more network capacity to be added first. In general, however, I also believe network operators need to remember that they can’t put the unused bandwidth they have in some inventory and sell it later. If unused, the bandwidth is lost and with it operators loose a prime opportunity to engage the customer and make us use it.


BROTHER OF SLEEP A film review by Christopher Null Copyright 1996 Christopher Null
Occasionally a film is conceived more as a series of images than as a story with a beginning, a middle, and an end. BROTHER OF SLEEP may not have been intended this way, but that's certainly how it came out.
Gorgeous Cinemascope photography (which is done no justice whatsoever on the videotape copy from which I reviewed this film) is what makes BROTHER OF SLEEP a standout. Shot in the still-untouched-by-time Austrian Alps, this picture is difficult to describe in two paragraphs. But I'll try.
Elias (Andre Eisermann) is born a mystery. Mystically imbued with a gift for music -- an innate talent capable of causing his listeners to see and become one with heaven, however briefly -- Elias finds his childhood a hard one. Considered a devil by the inhabitants of his tiny mountain village, he has only two friends -- similarly outcast Peter (Ben Becker) and his Elias's sister Elsbeth (Dana Vavrova).
As they grow to adulthood, the three find themselves in a bizarre sort of love triangle, still outcasts from the rest of the village. As things go from bad to worse, culminating in a jealousy-fueled catastrophe, the three are torn apart... and come back together one last time.
BROTHER OF SLEEP has "artsy" stamped all over it, and I realize it sounds *really* corny, but there's a lot more to it than what I've briefly described. While it has, in my opinion, an overly pessimistic view on life, the subtleties of theme about one's search for God away from the walls of the church and a spiritual link with the natural world make it all worthwhile. (As I mentioned before, the cinematography (by Joseph Vilsmaier [STALINGRAD], who also directed and produced) would certainly be outstanding on the big screen.) Also of note is the music, mostly on pipe organ (scored by Norbert J. Schneider), which equals any classical pieces I've ever heard.
Certainly not for everyone and likely to be inaccessible to many, thanks to its introspective and subtle style, BROTHER OF SLEEP is still a fine film that deserves to be seen.
In German with English subtitles.

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Liverpool pair Henderson, Gomez out of England's trip to Kosovo
England midfielder Jordan Henderson and defender Joe Gomez will miss Sunday's Euro 2020 qualifier at Kosovo due to illness and injury, the Football Association (FA) said on Saturday.
REUTERS: England midfielder Jordan Henderson and defender Joe Gomez will miss Sunday's Euro 2020 qualifier at Kosovo due to illness and injury, the Football Association (FA) said on Saturday.
Henderson, who is yet to completely recover from a viral infection, had missed Thursday's 7-0 victory over Montenegro at Wembley as Gareth Southgate's side booked their place in the finals of the competition as Group A winners.
His Liverpool team mate Gomez was booed by some fans when he entered as a substitute in that match, following a bust-up with Raheem Sterling on Monday, and misses the trip to Kosovo after sustaining a knee injury in training on Friday.
"Henderson arrived in camp with a viral infection that has not fully cleared... Gomez sustained a knock in training and has not recovered sufficiently enough to travel," the FA said in a statement http://www.thefa.com/news/2019/nov/16/jordan-henderson-and-joe-gomez-to-miss-kosovo-game-161119.
"The pair now return to their club meaning the Three Lions will head to Pristina on Saturday with a 23-man squad."
England have 18 points from seven games, while Kosovo are third in the group below Czech Republic with 11 points.
(Reporting by Shrivathsa Sridhar in Bengaluru; Editing by Christian Radnedge)


Team atofeedback for the govhack 2018 competition.
Team Leader
Work in IT. In this project i worked on documentation and ideas.
<EMAIL_ADDRESS>Web Developer
Architect and designed the applciation
<EMAIL_ADDRESS>Data planner
Data Explorer
<EMAIL_ADDRESS>Video Designer
I am doing video production and editing in my spare time
nathaniel@softgrow.com


The Northeast air zone is one of the seven broad air zones in British Columbia. It is located in the northeast part of the province, bordered by the Rocky Mountains to the west, Alberta to the east, and Yukon and the Northwest Territories to the north. The Northeast air zone covers the cities and communities in the Peace River Regional District including Fort St. John, Dawson Creek, Fort Nelson, the Districts of Chetwynd, Tumbler Ridge, Taylor, and Hudson’s Hope, the Village of Pouce Coupe; and the Treaty 8 First Nations communities of Blueberry River, Doig River, Halfway River, Prophet River, Saulteau, West Moberly and McLeod Lake. The largest population centre, Fort St. John, is home to the Ministry-operated air quality monitoring station. Other monitoring stations in the air zone are operated to monitor activities such as forestry products processing, and the oil and gas industry.
The top five most populous cities/towns in the Northeast Air Zone are:
| Municipality | Population (2021) |
|---|---|
| Fort St. John | 21,465 |
| Dawson Creek | 12,323 |
| Northern Rockies | 3,947 |
| Tumbler Ridge | 2,399 |
| Chetwynd | 2,302 |


logout
passiful/passiflora@<%= conf.packageJson.version %>
Copyright (c)2016 Tomoya Koyanagi, and Passiful ProjectMIT License https://opensource.org/licenses/mit-license.php


My interpretation of the DBC experience is that DBC exists to garner creativity.
Shereef describes the consumer mindset as a hindrance to creativity and limits learning. Consumer mindset is the idea that we sit back and judge a product, therefore we do not feel the urge to interact and make grand changes beyond criticizing from the outside looking in.
In contrast, he describes the Kitchen mindset that encourages creativity and the individual to take control of their own destiny. Kitchen mindset is the idea that everyone is contributing hands-on to create something yummy.
I just started the DBC experience, so my impression is pretty limited, other than there's a lot of info scattered in many places. I haven't seen much creativity yet in prep phase but I look forward to it.
There's a DBC thing that sparks a bit of passion in me. I dislike DBC's integrity statement. Allegedly, I "fall out of integrity" if I don't complete certain assignments on time and they send you an automated email to tell you that you've "fallen."
The way I see it: I may be late. I may be slow, but I have not. not. not. fallen out of integrity with DBC. According to Shereef's ideology: To stop trying is to fall out of integrity; To not pick up that knife and cook is falling out of integrity; To not love what I do but settling anyway is falling out of integrity.
DBC may not say it but Shereef's video says it. You don't have to be the brightest or most experienced. Just keep trying to contribute and effect change.
I don't know. There's a side of me that has millions of questions. Ultimately, I will need to learn to trust humans and time box. Because when I'm in the rabbit hole all by my lonely self, time is lost and I forget to find my way.
I wanted to join DBC to learn code. I expected to learn and I still expect to learn.
struggling along... WHEN I get to the light at the end of this tunnel, I expect you to lead me to another long dark tunnel. @devbootcamp
— Quynh Chen (@QuynhCodeLaw) September 28, 2014
EXCITED OR NERVOUS?
I'm excited. Very excited.


|
April , 2012
The meeting was called to order by President Jane
Ewing at 2:00 p.m. in King Room A at Pueblo West Library. Ten members
and two guests were present.
Members attending were:
-
Jane, KA0USA
- Bill, WA0KAQ
- Jim, NE0DA
- Bill, W0NHF
- Stan, KC0OYO
- Bill, KB0RPD
- Steve, KD0QCF
- Roger, KE0FI
- Jim, N0OBV
- Del, (awaiting license)
Guests: Carrie Worley; La Dawn Worley (KD0QMS)
Birthdays: David (KY6YYY); Bill
(KD0ICM); Clark (KD0OZY)
New Members: We welcome Roger, KE0FI, as
a new member or our club.
Newly Licensed Members: None
Members upgrading since last month: None
Members renewing since last meeting: Ted
(K0LDS); Jim, (N0OBV)
Memberships Expiring in March: Kirk (KD0LDH)
Memberships Expiring in April: None
Memberships Expiring in May: Amanda
(K1DDN); Jeff (K0JSC); Mason (WA6HSI); Jim (N0OBV)
ARRL Membership Report:
-
We have 33 members, 32 of whom are licensed. Of those
7 hold Technician licenses, 7 have General licenses, 3 hold Advanced
licenses, and 15 have Amateur Extra licenses. Of the 32 voting
members, 23 belong to ARRL. (71.9%)
New ARRL Memberships or Renewals: None
VE Session Report:
-
A VE Session was held before our meeting. Two
candidates took their exams, and both passed their Technician Class
requirements. One was our own club member, Del Milne.
Congratulations, Del!
News from the members:
(What have you done in the last month pertaining to amateur radio?)
-
David, KY6YYY, worked Scotland and Slovakia on HF. He
reported his 2-meter rig quit working during last week's club net.
-
Jim, NE0DA, has installed a new rotor, a 2-meter yagi
that KB0JIT built, and a new 2-meter vertical. He plans to put up his
Cushcraft A3S beam this week, depending on when help is available. He
also installed RMS Express using the WINMOR protocol for sending
e-mail without a computer, and now has a weather station on the internet.
-
Jim, N0OBV, has been having power line interference on
the HF bands for at least a year. The power company promised to come
out and check on the source Monday. Jim donated a signal generator to
the club for a future raffle or sale, and has given Neal a vintage
Globe Chief transmitter and a PK-232 TNC.
-
Del spent the month studying for his Technician
license and passed his exam at the VE Session held just before the
meeting. He and Paul, KB0JIT, also repaired the antenna at the
aircraft museum that the club will use for its Special Event station
in May.
-
Bill, W0NHF, reports he has been hearing white noise
interference every 70 KHz from 100 KHz through the 10 meter band. It
first started about 6 months ago and is S9 in strength.
-
Bill, KD0RPD, has been preparing to help with the
Chemical Stockpile Emergency Preparedness Program (CSEPP) exercise to
be held in May.
-
Stan, KC0OYO, has a new Wouxun handheld radio and has
installed a 2-meter beam and rotor.
-
Steve, KD0QCF, is enjoying making contacts on 2 meters.
-
Roger, KE0FI, is getting back into radio after being
off the air for a while. He has been reading reviews on equipment and
will be going to Denver this week to buy new equipment. He is looking
forward to Field Day and emergency preparedness exercises.
-
Jane, KA0USA, attended the April Ragchew, checked into
our club's nets and checked into the ARES SSB Net on 2-meter SSB.
-
Bill, WA0KAQ, attended the Ragchew for the first time
since last January. He reported receiving a LOTW confirmation for
Namibia and QSL cards from Tuvalu and Fiji. He worked EA9EU in Ceuta
& Melilla on the northern coast of Africa using 20 meter CW,
Guinea-Bissau (Guinea-Bis saw) on the west coast of Africa on 20
meter RTTY, and North Cook Island in the Pacific on 15 meter CW.
He has been playing with an Icom IC-91AD digital radio
on D-Star for a few weeks. Using it, he talked to Dwight, WB0HBJ,
using 70 cm while Dwight was in Des Moines, Cedar Rapids,
Indianapolis, and Colby, KS.
Thanks to Neal, Paul, Stan and Dwight, Bill's VHF/UHF
antenna is 8' higher than it has been for the last 8 years. They
replaced the PVC pipe and with a push-up pole and added a 4-element
2-meter beam pointed towards Colorado Springs to listen for SSB signals.
-
Guest La Dawn Worley, KD0QMS, has been active on 2 meters.
Ragchew Report:
Secretary's Report:
-
Meeting notes are e-mailed to all members and
prospects as soon as they are written and are posted on our website,
beginning with the January 2010 meeting. We also have a copy of the
minutes of last month's meeting at the sign-in table at each meeting
for anyone who would like to go through it. If anyone has questions
about the minutes, the Secretary will be happy to answer them and
make corrections if needed.
Treasurer's Report:
Ways & Means Report:
-
Jane (KA0USA) reported that the club's Bake Sale at
Walmart is scheduled for Sunday, June 3. Club members were asked to
start thinking about what they will be bringing to sell. Proceeds
from this sale will go toward the 2013 scholarship fund. Those who
are not able to attend may bring their baked goods to Bill and Jane's
home, 676 S. Dante Dr., ahead of time. Items that can be frozen until
the date can also be dropped off there. Monetary donations can also
be made in lieu of bake sale items. Unsold items will be available as
treats at Field Day. Call Jane, 647-9179, for further information.
-
Roger, KE0FI, donated $25 toward the bake sale.
Old Business:
New Business:
-
Letter of Resignation
-
Bill, WA0KAQ, has resigned as PWARC Secretary. He
cited health issues in his resignation letter.
-
Earlier this month Paul, KB0JIT, agreed to fill the
2012 term as Secretary, pending approval by the club. Bill, KB0RPD,
made a motion to accept Paul as Secretary, and Steve, KD0QCF,
seconded the motion. The vote was unanimous.
-
The Board of Directors will choose a new Board member
to replace Paul on the Board and announce the appointment at the May meeting.
-
Classes needed
-
VE Session May 12
Coming Events:
-
Each Tuesday - 7:00 p.m. First session of the PWARC
net on the Royal Gorge Ham Club repeater at Canon City (145.490 [-] PL103.5).
-
Each Tuesday - 7:30 p.m. Second session of the PWARC,
146.445 MHz FM simplex. Alternate frequency, 146.430 FM simplex.
-
Sat., May 5 - 9:00 a.m. - Ragchew - Meet for coffee or
breakfast at Hen House Café, 53 Palmer Lake Dr. (c/s S. Joe
Martinez Blvd.).
-
Sat., May 12 - Noon to 2:00 p.m. -Tentative VE
Session, Pueblo West Library, 298 S. Joe Martinez Blvd.
-
Sat., May 12 - 2:00 p.m. - Pueblo West Amateur Radio
Club meeting, Pueblo West Library, 298 S. Joe Martinez Blvd.
-
Sat., May 19 - 9 a.m. - 4 p.m. - Special Event Station
- Weisbrod B-24 Aircraft Museum, 31001 Magnuson Ave., Pueblo.
-
For other events, see the PWARC Calendar at www.qsl.net/na0pw/Calendar.htm
Next month's Program:
Raffle:
Adjournment:
Submitted by Bill Ewing, WA0KAQ
PWARC Secretary |