filecode.cpp

ncbi源码

            " * ATTENTION:\n"
            " *   Don't edit or commit this file into CVS as this file will\n"
            " *   be overridden (by DATATOOL) without warning!\n"
            " * ===========================================================================\n"
            " */\n";
    }
    return out;
}


CNcbiOstream& CFileCode::WriteUserCopyright(CNcbiOstream& out, bool header) const
{
    if (header) {
        WriteCopyrightHeader(out)
            << " */\n\n"
            << "/// @" << CDirEntry(GetUserHPPName()).GetName() << "\n"
            << "/// User-defined methods of the data storage class.\n"
            << "///\n"
            << "/// This file was originally generated by application DATATOOL\n"
            << "/// using the following specifications:\n";
        string name = CDirEntry(GetBaseHPPName()).GetName();
        WriteSpecRefs(out) <<
            "///\n"
            "/// New methods or data members can be added to it if needed.\n";
        if (CClassCode::GetDocRootURL().empty()) {
            out << "/// See also: " << name << "\n\n";
        } else {
            out << "/// See also: <a href=\"" << name << "\">" << name << "</a>\n\n";
        }
    } else {
        WriteCopyrightHeader(out) <<
            " * Author:  .......\n"
            " *\n"
            " * File Description:\n"
            " *   .......\n"
            " *\n"
            " * Remark:\n"
            " *   This code was originally generated by application DATATOOL\n"
            " *   using the following specifications:\n"
            " *   ";
        WriteSourceFile(out) << ".\n"
            " */\n";
    }
    return out;
}


CNcbiOstream& CFileCode::WriteLogKeyword(CNcbiOstream& out)
{
    out << "\n"
        "/*\n"
        "* ===========================================================================\n"
        "*\n"
        "* $""Log$\n"
        "*\n"
        "* ===========================================================================\n"
        "*/\n";
    return out;
}

void CFileCode::GenerateHPP(const string& path, string& fileName) const
{
    fileName = Path(path, GetBaseHPPName());
    CreateFileFolder(fileName);
    CDelayedOfstream header(fileName);
    if ( !header ) {
        ERR_POST(Fatal << "Cannot create file: " << fileName);
        return;
    }

    string hppDefine = GetBaseHPPDefine();
    WriteCopyright(header, true) <<
        "\n"
        "#ifndef " << hppDefine << "\n"
        "#define " << hppDefine << "\n"
        "\n"
        "// standard includes\n"
        "#include <serial/serialbase.hpp>\n";

    if ( !m_HPPIncludes.empty() ) {
        header <<
            "\n"
            "// generated includes\n";
        ITERATE ( TIncludes, i, m_HPPIncludes ) {
            header <<
                "#include " << Include(*i, true) << "\n";
        }
        header <<
            '\n';
    }

    CNamespace ns;
    if ( !m_ForwardDeclarations.empty() ) {
        bool begin = false;
        ITERATE ( TForwards, i, m_ForwardDeclarations ) {
            ns.Set(i->second, header);
            if ( !begin ) {
                header <<
                    "\n"
                    "// forward declarations\n";
                begin = true;
            }
            header <<
                "class " << i->first << ";\n";
        }
        if ( begin )
            header << '\n';
    }
    
    if ( !m_Classes.empty() ) {
        bool begin = false;
        ITERATE ( TClasses, i, m_Classes ) {
            if ( !i->hppCode.empty() ) {
                ns.Set(i->ns, header);
                if ( !begin ) {
                    header <<
                        "\n"
                        "// generated classes\n"
                        "\n";
                    if (CClassCode::GetDoxygenComments()) {
                        header
                            << "\n"
                            << "/** @addtogroup ";
                        if (!CClassCode::GetDoxygenGroup().empty()) {
                            header << CClassCode::GetDoxygenGroup();
                        } else {
                            header << "dataspec_" << i->code->GetModuleName();
                        }
                        header
                            << "\n *\n"
                            << " * @{\n"
                            << " */\n\n";
                    }
                    begin = true;
                }
                header << i->hppCode;
            }
        }
        if ( begin ) {
            if (CClassCode::GetDoxygenComments()) {
                header << "\n/* @} */";
            }
            header << "\n";
        }
    }

    if ( !m_Classes.empty() ) {
        bool begin = false;
        ITERATE ( TClasses, i, m_Classes ) {
            if ( !i->inlCode.empty() ) {
                ns.Set(i->ns, header, false);
                if ( !begin ) {
                    // have inline methods
                    header <<
                        "\n"
                        "\n"
                        "\n"
                        "\n"
                        "\n"
                        "///////////////////////////////////////////////////////////\n"
                        "///////////////////// inline methods //////////////////////\n"
                        "///////////////////////////////////////////////////////////\n";
                    begin = true;
                }
                header << i->inlCode;
            }
        }
        if ( begin ) {
            header <<
                "///////////////////////////////////////////////////////////\n"
                "////////////////// end of inline methods //////////////////\n"
                "///////////////////////////////////////////////////////////\n"
                "\n"
                "\n"
                "\n"
                "\n"
                "\n";
        }
    }
    ns.Reset(header);
    header <<
        "\n"
        "#endif // " << hppDefine << "\n";
    header.close();
    if ( !header )
        ERR_POST(Fatal << "Error writing file " << fileName);
}


void CFileCode::GenerateCPP(const string& path, string& fileName) const
{
    fileName = Path(path, GetBaseCPPName());
    CreateFileFolder(fileName);
    CDelayedOfstream code(fileName);
    if ( !code ) {
        ERR_POST(Fatal << "Cannot create file: " << fileName);
        return;
    }

    WriteCopyright(code, false) <<
        "\n"
        "// standard includes\n";
    if (!m_PchHeader.empty()) {
        code <<
            "#include <" << m_PchHeader << ">\n";
    }
    code <<
        "#include <serial/serialimpl.hpp>\n"
        "\n"
        "// generated includes\n"
        "#include " << Include(GetUserHPPName()) << "\n";

    if ( !m_CPPIncludes.empty() ) {
        ITERATE ( TIncludes, i, m_CPPIncludes ) {
            code <<
                "#include " <<
                Include(m_CodeGenerator->ResolveFileName(*i), true) <<
                "\n";
        }
    }

    CNamespace ns;
    if ( !m_Classes.empty() ) {
        bool begin = false;
        ITERATE ( TClasses, i, m_Classes ) {
            if ( !i->cppCode.empty() ) {
                ns.Set(i->ns, code, false);
                if ( !begin ) {
                    code <<
                        "\n"
                        "// generated classes\n"
                        "\n";
                    begin = true;
                }
                code << i->cppCode;
            }
        }
        if ( begin )
            code << '\n';
    }
    ns.Reset(code);

    code.close();
    if ( !code )
        ERR_POST(Fatal << "Error writing file " << fileName);
}


bool CFileCode::GenerateUserHPP(const string& path, string& fileName) const
{
    return WriteUserFile(path, GetUserHPPName(), fileName,
                         &CFileCode::GenerateUserHPPCode);
}


bool CFileCode::GenerateUserCPP(const string& path, string& fileName) const
{
    return WriteUserFile(path, GetUserCPPName(), fileName,
                         &CFileCode::GenerateUserCPPCode);
}


bool CFileCode::ModifiedByUser(const string& fileName,
                               const list<string>& newLines) const
{
    // first check if file exists
    CNcbiIfstream in(fileName.c_str());
    if ( !in ) {
        // file doesn't exist -> was not modified by user
        return false;
    }

    CChecksum checksum;
    bool haveChecksum = false;
    bool equal = true;
    
    list<string>::const_iterator newLinesI = newLines.begin();
    SIZE_TYPE lineOffset = 0;
    while ( in ) {
        char buffer[1024]; // buffer must be as big as checksum line
        in.getline(buffer, sizeof(buffer), '\n');
        SIZE_TYPE count = in.gcount();
        if ( count == 0 ) {
            // end of file
            break;
        }
        if ( haveChecksum || in.eof() ) {
            // text after checksum -> modified by user
            //    OR
            // partial last line -> modified by user
            ERR_POST(Info <<
                     "Will not overwrite modified user file: "<<fileName);
            return true;
        }

        bool eol;
        // check where EOL was read
        if ( in.fail() ) {
            // very long line
            // reset fail flag
            in.clear(in.rdstate() & ~in.failbit);
            eol = false;
        }
        else {
            // full line was read
            --count; // do not include EOL symbol
            eol = true;
        }

        // check for checksum line
        if ( lineOffset == 0 && eol ) {
            haveChecksum = checksum.ValidChecksumLine(buffer, count);
            if ( haveChecksum )
                continue;
        }

        // update checksum
        checksum.AddChars(buffer, count);
        // update equal flag
        if ( equal ) {
            if ( newLinesI == newLines.end() )
                equal = false;
            else if ( newLinesI->size() < lineOffset + count )
                equal = false;
            else {
                const char* ptr = newLinesI->data() + lineOffset;
                equal = memcmp(ptr, buffer, count) == 0;
            }
        }
        lineOffset += count;
        if ( eol ) {
            checksum.NextLine();
            if ( equal ) {
                // check for end of line in newLines
                equal = newLinesI->size() == lineOffset;
                ++newLinesI;
            }
            lineOffset = 0;
        }
    }

    if ( haveChecksum ) {
        // file contains valid checksum -> it was not modified by user
        return false;
    }

    // file doesn't have checksum
    // we assume it modified if its content different from newLines
    return !equal  ||  newLinesI != newLines.end();