“The time has come…to talk of many [technologies].” –Lewis Carroll(‘The Walrus and the Carpenter’)
Archive for May, 2006
C++ Boost Filesystem Library(Part III): Example Programs
8My earlier posts on C++ Boost Libraries introduced the Boost Filesystem Library and discussed some example programs that make use of it. I discuss two more examples in this post. (Be sure to include the needed boost header files as noted in the earlier posts, including creation of the alias to the boost filesystem namespace: namespace bfs = boost::filesystem; )
1. A function to search for a file.
[cpp]
// Search for a file with the name ‘filename’ starting in directory ‘dir_path’, copy the path of the file in ‘pfound’ if found, and return true.
// Else return false.
bool find_file(const bfs::path & dir_path, const std::string & file_name, bfs::path & pfound)
{
if( !exists(dir_path) || !is_directory(dir_path) )
return false;
bfs::directory_iterator iter(dir_path), end_iter;
for(; iter!= end_iter; ++iter)
{
if( bfs::is_directory(*iter) )
{
if( find_file(*iter, file_name, pfound) )
return true;
}
else if( iter->leaf() == file_name )
{
pfound = *iter;
return true;
}
}
return false;
}
[/cpp]
The function first verifies if the path passed in ‘path_dir’ exists and if it is a directory. Then it creates a ‘directory_iterator’ object(introduced in the previous post) by passing this path to its constructor. The loop then iterates over all the contents of the directory, and for every sub-directory found, it calls itself recursively passing this new directory as the starting point. Every file that is found is compared with the file that is to be searched(file_name), and if a match is found, the path is copied into ‘pfound’ and function returns true. If nothing is found by the end of the loop, ‘false’ is returned. Remember that as discussed earlier, iter->leaf() returns the last part of a path – the file name. Applying indirection operator to the directory_iterator object returns the file it is pointing to.
2. A simple directory listing (ls/dir) program. else if( !bfs::is_directory(p) ) std::cout<<"In directory:"< Most of the examples inspired/taken from the Boost website. The website documentation also contains more help on the various formats in which the paths to the files can be represented. The function ‘native_file_string()’ used in the Example 2 above returns the path in the native format(using ‘/’ as a file separator on Unix platforms and ‘\’ on Windows platforms, for example). To pass the path names as ‘path’ objects, use the services from fstream.hpp. All Filesystem library related exceptions are available in exception.hpp. The header convenience.hpp contains a few convenience functions(like change_extension()). You can start from the documentation page on the website for further information.
If you are a plugin or a theme developer for the WordPress software, then you probably are going to love these two cheatsheets – created as JPG images so that they can be set as a desktop wallpaper! Screenshots for the Plugin cheatsheet and the Theme cheatsheet are available at the headzoo.com website. Send suggestions or any other feedback to the author. More cheatsheets related to programming technologies are available here. For more such cheatsheets, there is always Google Search :) 1. Simple program to demonstrate the use of file creation and removal operations: 2. Removing all the files from a directory: The other examples needs an introduction to the directory_iterator class which is used to iterate over the contents of a directory. A simple usage looks like this: Using a ‘directory_iter’ object, we can create a function similar to the ‘remove_all()’ function that we used in Example 2.
Its close to one year now since the 3.2 version of the Movable Type blog publishing software was released last year. Jay Allen, Product Manager at Six Apart, has announced yesterday that the first beta of the next version of the software, Movable Type 3.3, will be released on May 31. Good news: We’ve got a new version of Movable Type on the way, and we wanted to let you know that the beta is coming soon. We plan to start the Movable Type 3.3 beta test on Wednesday, May 31. The highlight this time around about the beta development stage is that a separate blog will be serving as a common place for everyone to keep informed(and get technical support) about the latest developments with the beta product. There is also a tight 3-week deadline for beta testing this time, informs Jay Allen. So whoever is a Movable Type fan and would like to get their hands dirty by test driving its multiple beta versions that would be released in the coming next few weeks, get ready and be prepared for the D-day. Update: More details about the new features of the Beta version to be released are here: What’s new in Movable Type 3.3? So why should an Ajax developer be interested in the recently released Google Web Toolkit(GWT)? One possible reason could be to overcome the shortcomings of the typical Ajax web development model as noted in my earlier post. Firstly, a framework always provides a head start to a project, allowing the developers to worry only about writing the application logic; user interface elements, the plumbing work needed for the communication between the client and the server are provided by the framework itself. The more specific benefits of using the Google Web Toolkit are: Refer to points 2 & 3 in my earlier post.
Refer to point 1 in my earlier post. Being able to use Java to create Ajax applications also means better integration with the rest of the Java web development technologies like JSP, JSF, etc(note that code written using GWT uses the Java Web UI class library which is not related to any of the Java standard libraries and this code is statically translated to Javascript and HTML code before making available to the server. Integration would be limited to sharing something like a Java component between a JSP page and the code written using GWT). This may not appeal to those who are using other server-side technologies like PHP and ASP.NET. Java language also boasts of better programmer IDEs and tools with good support for Unit Testing and Refactoring. In fact, GWT itself has good JUnit integration through easy to use class libraries in the package com.google.gwt.junit. Javascript code can still be embedded within the Java code if only the services of the Javascript language are going to solve a particular problem, by using the Javascript Native Interface(JSNI)(on the lines of JNI). See this for more information.
Having said all this, I am not a big fan of static translation of one programming language to the other. If it were as unified as in ASP.NET(see ASP.NET WebParts; all the translation happens at run-time), I would have welcomed it whole-heartedly. But different programming languages are created to solve different problems, and they are optimized to that specific job. I hate Javascript language for many reasons(as I do in case of Java) but still believe that Javascript is better oriented towards creating client-side code for the web browsers than Java language is(when the intention is to create a web interface). Are we going to use Java idioms here or are we going to try to imitate the Javascript idioms in the Java code? How many Java libraries are supported by the GWT SDK tools? What about the unsupported libraries whose functionality is needed for the application? Secondly, the entire translation process is lengthy and inefficient: create an empty GWT application using the GWT SDK, fire up your favourite Java editor(eg: Eclipse) and create the Java source files in it, translate these Java files to Javascript + HTML files and finally integrate them with the rest of the server-side code(PHP, JSP etc). But there are advantages we get out of this investment as noted in the above mentioned points. Not all the standard Java libraries are supported by GWT. For example, only java.lang and a part of java.util are supported by the GWT tools, which means the code written using Java libraries not supported by GWT cannot be translated by the GWT tools. The developer needs to make a call whether to achieve the desired functionality by writing custom Java code or by writing the code in Javascript.(I would be tempted to go the second way as that would allow me to use the same code in other applications that don’t make use of GWT). By the way, why don’t we have the access to the GWT source code? Isn’t Google a big supporter of the Free Software community? For developer centric GWT related discussion, go to the GWT Support Forums.
[cpp]
void sls(const bfs::path & p)
{
unsigned long fc=0, dc=0;
if( !bfs::exists(p) )
std::cout<<"\nFile Not Found:"<
std::cout<<"\nFound: " << p.native_file_string() << "\n";
for(; iter != end_iter; ++iter)
{
try {
if(bfs::is_directory(*iter))
{
++dc;
std::cout<
}
else
{
++fc;
std::cout<
}
} catch(const std::exception & ex) {
std::cout<
}
std::cout<
} //sls
[/cpp]
The function simply iterates over all the contents of the directory passed to it(p) and prints every file and directory that is found. [Directory] tag is added to the directory names, and at the end of the program the total count of the files and directories is printed. This program only prints the contents of the directory passed, it doesn’t traverse its sub-directories. Can you combine the general idea of the above two examples to create a directory listing program that displays the files of all the sub-directories recursively? You can also print more information about the files by using boost filesystem functions like is_symbolic_link(), file_size(), last_write_time() etc[discussed in the earlier posts].
WordPress Plugin and Theme Cheatsheets
4
Official google cheatsheet is here but I think you will like this google cheatsheet more.
C++ Boost Filesystem Library(Part II): Example Programs
11
Continuing from where I had left in my earlier post containing the basics of the C++ Boost Filesystem Library, below are some example programs that make use of some common facilities available in the Boost Filesystem Library. I assume that all the code snippets shown in this post are properly nested within the main() function apart from including the following things:
[cpp]
#include
#include
#include
namespace bfs=boost::filesystem;
[/cpp]
[cpp]
std::cout<<"Enter your choice:\n";
std::cout<<"1. Create folder\n2. Rename File\n3. Remove File\n4. Copy File\n";
char ch;
std::cin>>ch;
std::string name, new_name;
switch(ch)
{
case ’1′:
std::cout<<"Enter folder name:";
std::cin>>name;
bfs::create_directory(bfs::path(name));
break;
case ’2′:
std::cout<<"Enter file name:";
std::cin>>name;
std::cout<<"Enter new name:";
std::cin>>new_name;
bfs::rename(name, new_name);
break;
case ’3′:
std::cout<<"Enter file name:";
std::cin>>name;
bfs::remove(bfs::path(name));
break;
case ’4′:
std::cout<<"Enter file name:";
std::cin>>name;
std::cout<<"Enter new name:";
std::cin>>new_name;
bfs::copy_file(name, new_name);
break;
}
std::cout<<"Operation finished."<
[/cpp]
Pay attention to the following four Boost Filesystem functions used:
[cpp]
bfs::create_directory(bfs::path(name));
bfs::rename(name, new_name);
bfs::remove(bfs::path(name));
bfs::copy_file(name, new_name);
[/cpp]
They all do what their function names suggest. Like its always the case with the simple example programs, no error checking is done here ;)
[cpp]
std::cout<<"Enter the name of the folder to empty:";
std::string name;
std::cin>>name;
bfs::remove_all(bfs::path(name));
std::cout<<"Operation completed."<
[cpp]
bfs::path p(“folder”);
bfs::directory_iterator dir_iter(p), dir_end;
for(;dir_iter != dir_end; ++dir_iter)
{
std::cout<<(*dir_iter).leaf();
}
[/cpp]
A directory_iterator object can be created by passing it a name of a directory. Applying the prefix increment operator(++) to it makes it point to the next file in the directory. Applying the indirection operator(*) returns the file currently being pointed to, as a ‘path’ object. We call the leaf() method on the returned ‘path’ object to print the file name. Using ‘dir_iter->leaf()’ instead of ‘(*dir_iter).leaf()’ has the same effect.
3. Removing all the files from a directory by iteration:
[cpp]
std::cout<<"Enter the name of the folder to empty:";
std::string name;
std::cin>>name;
bfs::path p(name);
if(!bfs::exists(p) || !bfs::is_directory(p))
{
std::cout<<"Invalid input."<
}
bfs::directory_iterator dir_iter(p), dir_end;
for(;dir_iter != dir_end; ++dir_iter)
{
std::cout<<"Removing file: "<
bfs::remove(*dir_iter);
}
std::cout<<"Operation Completed."<
Simple error checking is done on the input before calling the remove()function on all the files present in the specified folder. Will follow up with more examples using the Boost Filesystem Library.
Movable Type 3.3 Beta To Be Released On May 31
1
You can read the announcement here:
Coming soon: Movable Type 3.3 (beta)
Should I Be Developing Ajax Applications using Google Web Toolkit(GWT)?
0
Related Post: A Case Against Ajax Web Development Model
Recent Comments