source: src/Bond/AdjacencyMatcher/AdjacencyMatcher.cpp@ eaef9b

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2015 Frederik Heber. All rights reserved.
 *
 *
 *   This file is part of MoleCuilder.
 *
 *    MoleCuilder is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    MoleCuilder is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with MoleCuilder.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * AdjacencyMatcher.cpp
 *
 *  Created on: Jul 19, 2015
 *      Author: heber
 *
 *
 *  This is mostly copy&pasted from AdjacencyMatcher.cpp
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "CodePatterns/MemDebug.hpp"

#include <boost/exception/all.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/tokenizer.hpp>

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <sstream>
#include <string>

#include "Adjacency.hpp"

#include "CodePatterns/toString.hpp"

typedef std::set<detail::Adjacency> adjacencies_t;

using namespace detail;

namespace bf = boost::filesystem;

typedef boost::error_info<
                struct tag_IllegalTesselationFileContent_LineNumber,
                int> IllegalTesselationFileContent_LineNumber;

typedef boost::error_info<
                struct tag_IllegalTesselationFileContent_Entries,
                int> IllegalTesselationFileContent_Entries;

typedef boost::error_info<
                struct tag_IllegalTesselationFileContent_Line,
                int> IllegalTesselationFileContent_Line;

//!> Exception for illegal lines encountered in adjacencies files
struct IllegalTesselationFileContentException:
                virtual boost::exception, virtual std::exception { };

Adjacency::index_t toIndex(const std::string &_element)
{
        Adjacency::index_t index;
        std::stringstream tokenstring(_element);
        tokenstring >> index;
        return index;
}

template <class T>
std::ostream& operator<<(
                std::ostream &_ost,
                const std::set<T> &elements)
{
        for( const T elem : elements)
                _ost << elem << std::endl;
        return _ost;
}

/** Parses a adjacencies file into a vector of Adjacencys.
 *
 * \param _filename name of file to parse
 * \return adjacencies_t structure filled with adjacency index triples
 */
const adjacencies_t parseFile(const boost::filesystem::path &_filename)
{
        adjacencies_t adjacencies;

        std::ifstream infile(_filename.string().c_str());
        boost::char_separator<char> sep(" \t");

        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
        std::string line;
        while (!infile.eof()) {
                std::getline(infile, line);
                tokenizer tokens(line, sep);
                Adjacency::indices_t indices;
                const int entries = std::distance( tokens.begin(), tokens.end() );
                // check for empty lines
                if (entries == 0)
                        continue;
                std::transform(
                                tokens.begin(),
                                tokens.end(),
                                std::back_inserter(indices),
                                toIndex);
                adjacencies.insert(Adjacency(indices));
        }
        infile.close();

        return adjacencies;
}

int main(int argc, char **argv) {

        /// check arguments and give usage
        if (argc <= 2) {
                std::cerr << "Usage: " << argv[0] << " <list of files>\n";
                std::cerr << "At least two adjacencies files need to be specified that contain\n";
                std::cerr << "each three indices per line.\n";

                return 255;
        }

        /// read in files and parse into structures
        typedef std::multimap<adjacencies_t, std::string> adjacencies_filename_t;
        //!> contains all adjacencies parsed from files
        adjacencies_filename_t adjacencyfiles;
        for (int i=1; i<argc;++i) {
                const bf::path filename(argv[i]);
                if (bf::exists(filename)) {
                        try {
                                adjacencies_t adjacencies = parseFile(filename);
                                adjacencyfiles.insert(
                                                std::make_pair(adjacencies, filename.string()) );
                        } catch (IllegalTesselationFileContentException &e) {
                                std::cerr << "Illegal line at "
                                                << *boost::get_error_info<IllegalTesselationFileContent_LineNumber>(e)
                                                << " encountered with "
                                                << *boost::get_error_info<IllegalTesselationFileContent_Entries>(e)
                                                << " entries in "
                                                << filename.string()
                                                << ", aborting.\n";
                                return 5;
                        }
                } else {
                        std::cerr << "The following file does not exist "
                                        << filename.string() << ", aborting.\n";
                        return 5;
                }
        }

        /// make comparison for equivalence
        assert( adjacencyfiles.size() >= 2 );
        adjacencies_filename_t::const_iterator advancer = adjacencyfiles.begin();
        adjacencies_filename_t::const_iterator iter = advancer++;

        bool AllEqual = true;
        while( advancer != adjacencyfiles.end() ) {
//        std::cout << "Comparing " << *advancer << " with " << *iter << std::endl;
                if (advancer->first == iter->first) {
                        std::cout << "MATCH: "
                                        << advancer->second << " and " << iter->second
                                        << std::endl;
                } else {
                        std::cout << advancer->first << " and " << iter->first
                                        << " don't match.\n";
                        AllEqual = false;
                }
                iter = advancer++;
        }

        // exit (convert bool to int)
        return (AllEqual ? 0 : 1);
}