This file is indexed.

/usr/include/pbseq/alignment/simulator/ContextOutputList.hpp is in libblasr-dev 0~20161219-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
#ifndef _SIMULATOR_CONTEXT_OUTPUT_LIST_HPP_
#define _SIMULATOR_CONTEXT_OUTPUT_LIST_HPP_

#include <stdlib.h>
#include <map>
#include <iostream>
#include <fstream>
#include <string>
#include "../../pbdata/utils.hpp"
#include "OutputList.hpp"


class ContextOutputList {
public:
    std::map<std::string, OutputList*> outputMap;
    int contextLength;
    int ParsePair(std::string &output, std::string &outStr, int &outCount){ 
        std::string contextStr, outCountStr;
        int i;
        for (i = 0; i < output.size(); i++) {
            if (output[i] == '=') {
                int start = 0;
                while(start < i and (output[start] == ' ' or output[start] == '\t')) { start++;}
                outStr.assign(&output[start], i-start);
                outCountStr.assign(&output[i+1], output.size()-i-1);
                outCount = atoi(outCountStr.c_str());
                return 1;
            }
        }
        return 0;
    }

    int SampleRandomContext(std::string refContext, std::string &readContext) {
        //
        // Chec to see if there is a distribution for this ref context, if
        // not, just return the ref context so that things may proceed,
        // but return a fail code.
        //
        if (outputMap.find(refContext) == outputMap.end()) {
            readContext = refContext;
            return 0;
        }
        else {
            outputMap[refContext]->SelectRandomContect(readContext);
            return 1;
        }
    }


    void Read(std::string &inName) {
        ifstream in;
        CrucialOpen(inName, in, std::ios::in);
        Read(in);
    }

    void Read(ifstream &in) {
        int nLines = 0;
        contextLength = 0;
        while(in) {
            std::string context;
            if (!(in >> context)) break;

            contextLength = context.size();
            std::string outputsLine;
            getline(in,outputsLine);
            // parse ctx=num; pairs
            int i;
            int e;
            i = 0;
            if (outputMap.find(context) == outputMap.end()) {
                outputMap[context] = ProtectedNew<OutputList>();
            }

            while(i < outputsLine.size()) {
                e = i+1;
                while(e < outputsLine.size() and outputsLine[e] != ';') e++;
                std::string pairStr;
                pairStr.assign(&outputsLine[i], e-i);
                if (e > i + 1) {
                    std::string outStr;
                    int outCount;
                    ParsePair(pairStr, outStr, outCount);
                    outputMap[context]->AddOutput(outStr, outCount);
                }
                i = e + 1;
            }
            outputMap[context]->StoreCumulativeCounts();
        }
    }

    void Free() {
        std::map<std::string,OutputList*>::iterator mapIt;
        for (mapIt = outputMap.begin(); mapIt != outputMap.end(); ++mapIt) {
            if (mapIt->second) {delete mapIt->second;}
        }
    }
};


#endif