C++ Attributes::size方法代码示例

RowCollection<Group,Hash>::RowCollection(boost::shared_ptr<Query> const& query, const string& name, const Attributes& attributes, size_t chunkSize)
: _query(query), _attributes(attributes), _chunkSize(chunkSize), _sizeBuffered(0), _mode(RowCollectionModeAppend)
{
    assert(!attributes.empty());
    assert(chunkSize >= 2);

    // Use (CONFIG_MEM_ARRAY_THRESHOLD / 10) as the #bytes the unflushed items may have.
    _maxSizeBuffered = Config::getInstance()->getOption<size_t>(CONFIG_MEM_ARRAY_THRESHOLD) * MiB / 10;

    // Push the empty tag
    Attributes attributesWithET(attributes);
    attributesWithET.push_back(AttributeDesc(attributes.size(), DEFAULT_EMPTY_TAG_ATTRIBUTE_NAME,
           TID_BOOL, AttributeDesc::IS_EMPTY_INDICATOR, 0));

    // get the schema
    Dimensions dims(2);
    dims[0] = DimensionDesc("Row", 0, MAX_COORDINATE, 1, 0);
    dims[1] = DimensionDesc("Column", 0, MAX_COORDINATE, _chunkSize, 0);
    ArrayDesc schema(name, attributesWithET, dims);

    // create a MemArray
    _theArray = make_shared<MemArray>(schema,query);

    // get the array iterators
    _arrayIterators.reserve(attributes.size());
    for (size_t t=0; t<attributes.size(); ++t) {
        _arrayIterators.push_back(_theArray->getIterator(t));
    }
}

/**
 * Function: Show_attributes
 *
 * Display both the key and value for an Attributes map.
 *
 * Since this is a non-critical message, it is only shown when the debug value
 * is set high enough.
 *
 * Parameter: attributes Defined as std::map<std::string, std::string> pair.
 *            Most commonly found in data as a "name = value" pair.
 */
void Show_attributes(std::ostream& os, Attributes& attributes)
{
	Monday_out(VERBOSE_LEVEL2, os, "- Num attributes: %d\n", attributes.size());
	for(Attributes::iterator i = attributes.begin(); i != attributes.end(); ++i)
	{
		Monday_out(VERBOSE_LEVEL2, os, "  \"%s\" = \"%s\"\n", i->first.c_str(), i->second.c_str());
	}
}

void
PropertyList::AddAttributes(const Attributes& attributes)
{
	RemoveAll();
	for (unsigned int i = 0; i < attributes.size(); i++) {
		AddRow(new PropertyRow(attributes[i].fName, attributes[i].fValue));
	}
}

size_t TupleArray::getTupleFootprint(Attributes const& attrs)
{
    size_t res =0, n = attrs.size();
    for(size_t i=0; i<n; i++)
    {
        size_t attSize = attrs[i].getSize();
        if(attSize == 0)
        {   //variable size
            attSize = Config::getInstance()->getOption<int>(CONFIG_STRING_SIZE_ESTIMATION);
        }
        res += Value::getFootprint(attSize);
    }
    return res + sizeof(Tuple) + sizeof(shared_ptr<Tuple>);
}

GLuint
Shader::create(const char *vshSrc, const char *fshSrc, GLuint *vshId, GLuint *fshId, const Attributes &attributes)
{
    *vshId = compile(GL_VERTEX_SHADER, vshSrc);
    *fshId = compile(GL_FRAGMENT_SHADER, fshSrc);
    
    // create shader program
    GLuint programId = glCreateProgram();
    
    if (programId == 0) {
        OG_LOGERR("Shader", "could not create shader program");
        return 0;
    }
    
    glAttachShader(programId, *vshId);   // add the vertex shader to program
    glAttachShader(programId, *fshId);   // add the fragment shader to program
    
    // Bind attribute locations
    // this needs to be done prior to linking
    for(int i = 0; i < attributes.size(); i++)
    {
        glBindAttribLocation(programId, attributes[i].first, attributes[i].second);
    }
    
    glLinkProgram(programId);   // link both shaders to a full program
    
    // check link status
    GLint linkStatus;
    glGetProgramiv(programId, GL_LINK_STATUS, &linkStatus);
    if (linkStatus != GL_TRUE) {
        OG_LOGERR("Shader", "could not link shader program. error log:");
        GLchar infoLogBuf[1024];
        GLsizei infoLogLen;
        glGetProgramInfoLog(programId, 1024, &infoLogLen, infoLogBuf);
        cerr << infoLogBuf << endl << endl;
        
        glDeleteProgram(programId);
        
        return 0;
    }
    
    return programId;
}

void
DevicesView::AddDeviceAndChildren(device_node_cookie *node, Device* parent)
{
	Attributes attributes;
	Device* newDevice = NULL;

	// Copy all its attributes,
	// necessary because we can only request them once from the device manager
	char data[256];
	struct device_attr_info attr;
	attr.cookie = 0;
	attr.node_cookie = *node;
	attr.value.raw.data = data;
	attr.value.raw.length = sizeof(data);

	while (dm_get_next_attr(&attr) == B_OK) {
		BString attrString;
		switch (attr.type) {
			case B_STRING_TYPE:
				attrString << attr.value.string;
				break;
			case B_UINT8_TYPE:
				attrString << attr.value.ui8;
				break;
			case B_UINT16_TYPE:
				attrString << attr.value.ui16;
				break;
			case B_UINT32_TYPE:
				attrString << attr.value.ui32;
				break;
			case B_UINT64_TYPE:
				attrString << attr.value.ui64;
				break;
			default:
				attrString << "Raw data";
		}
		attributes.push_back(Attribute(attr.name, attrString));
	}

	// Determine what type of device it is and create it
	for (unsigned int i = 0; i < attributes.size(); i++) {
		// Devices Root
		if (attributes[i].fName == B_DEVICE_PRETTY_NAME
			&& attributes[i].fValue == "Devices Root") {
			newDevice = new Device(parent, BUS_NONE,
				CAT_COMPUTER, B_TRANSLATE("Computer"));
			break;
		}

		// ACPI Controller
		if (attributes[i].fName == B_DEVICE_PRETTY_NAME
			&& attributes[i].fValue == "ACPI") {
			newDevice = new Device(parent, BUS_ACPI,
				CAT_BUS, B_TRANSLATE("ACPI bus"));
			break;
		}

		// PCI bus
		if (attributes[i].fName == B_DEVICE_PRETTY_NAME
			&& attributes[i].fValue == "PCI") {
			newDevice = new Device(parent, BUS_PCI,
				CAT_BUS, B_TRANSLATE("PCI bus"));
			break;
		}

		// ISA bus
		if (attributes[i].fName == B_DEVICE_BUS
			&& attributes[i].fValue == "isa") {
			newDevice = new Device(parent, BUS_ISA,
				CAT_BUS, B_TRANSLATE("ISA bus"));
			break;
		}

		// PCI device
		if (attributes[i].fName == B_DEVICE_BUS
			&& attributes[i].fValue == "pci") {
			newDevice = new DevicePCI(parent);
			break;
		}

		// ACPI device
		if (attributes[i].fName == B_DEVICE_BUS
			&& attributes[i].fValue == "acpi") {
			newDevice = new DeviceACPI(parent);
			break;
		}

		// ATA / SCSI / IDE controller
		if (attributes[i].fName == "controller_name") {
			newDevice = new Device(parent, BUS_PCI,
				CAT_MASS, attributes[i].fValue);
		}

		// SCSI device node
		if (attributes[i].fName == B_DEVICE_BUS
			&& attributes[i].fValue == "scsi") {
			newDevice = new DeviceSCSI(parent);
			break;
		}

//.........这里部分代码省略.........

int main(int argc, char* argv[])
{
    namespace js = anu_am::json;

    char* scalarPath = argv[1];
    char* fieldPath  = argv[2];

    if (argc < 3)
    {
        std::cerr << "Usage:" << argv[0] << " SCALARS FIELD [OUTPUT]"
                  << std::endl;
        return 1;
    }

    // Read the data for this process.
    NCFileInfo const info = readFileInfo(fieldPath);
    Variable const var = findVolumeVariable(info);

    std::vector<size_t> dims = readDimensions(info);
    CubicalComplex complex(dims.at(0), dims.at(1), dims.at(2));
    Vertices vertices(dims.at(0), dims.at(1), dims.at(2));

    assert(dims == readDimensions(scalarPath));

    Scalars::DataPtr scalarData = readVolumeData<Value>(scalarPath);
    Scalars scalars(complex, scalarData);

    Field::DataPtr fieldData = readVolumeData<FieldItem>(fieldPath);
    Field field = Field(dims.at(0), dims.at(1), dims.at(2), fieldData);

    // Process the data.
    std::map<Cell, Boundary> chains = chainComplex(complex, field);

    std::vector<Cell> const sources =
        criticalCellsSorted(complex, scalars, field);
    size_t const n = sources.size();

    SimpleComplex const simple = simpleChainComplex(
        complex, scalars, chains, sources);

    std::vector<Pairing<Cell> > const pairs = persistencePairing(simple);

    // Generate metadata
    std::string const parentID = guessDatasetID(fieldPath, info.attributes());
    std::string const thisID   = derivedID(parentID, "persistence", "PP");

    std::string const outfile =
        argc > 3 ? argv[3] : (stripTimestamp(thisID) + ".txt");

    js::Array const predecessors = js::Array
        (parentID)
        (guessDatasetID(scalarPath, readFileInfo(scalarPath).attributes()));

    js::Object const description = js::Object
        ("id"          , thisID)
        ("process"     , "Critical Cell Persistence Pairs")
        ("sourcefile"  , __FILE__)
        ("revision"    , js::Object("id", GIT_REVISION)("date", GIT_TIMESTAMP))
        ("parent"      , parentID)
        ("predecessors", predecessors)
        ("parameters"  , js::Object());

    // Write data
    std::stringstream tmp;

    tmp << "# Persistence pairs for " << scalarPath
        << std::endl
        << "#   format: <birth> <death> <dimension> <creator xyz> <destructor xyz>"
        << std::endl;

    for (size_t i = 0; i < pairs.size(); ++i)
    {
        size_t const j = pairs.at(i).partner;

        if (j > i)
        {
            Cell const v = sources.at(i);
            Cell const w = j >= n ? sources.at(i) : sources.at(j);

            tmp << std::fixed << std::setprecision(6);

            tmp << std::setw(12) << cellValue(v, scalars, vertices) << " "
                << std::setw(12);

            if (w == v)
                tmp << "inf";
            else
                tmp << cellValue(w, scalars, vertices);

            tmp << "    "
                << complex.cellDimension(v) << "    "
                << complex.cellPosition(v) << "    ";

            if (w == v)
                tmp << "   -      -      -  ";
            else
                tmp << complex.cellPosition(w);

            tmp << std::endl;
        }
//.........这里部分代码省略.........

int main(int argc, char* argv[])
{
    char* infile = argv[1];

    if (argc < 2)
    {
        std::cerr << "Usage:" << argv[0] << " INPUT" << std::endl;
        return 1;
    }

    FileBuffer data(infile);
    NCFile<FileBuffer> file(data);

    std::vector<Dimension> const dims  = file.dimensions();
    std::vector<Variable>  const vars  = file.variables();
    Attributes const attrs = file.attributes();
    size_t i;

    std::cout << "netcdf " << stripname(infile) << " {" << std::endl;

    std::cout << "dimensions:" << std::endl;
    for (i = 0; i < dims.size(); ++i)
    {
        Dimension d = dims.at(i);
        std::cout << "\t" << d.name << " = " << d.size
                  << " ;" << std::endl;
    }
    std::cout << std::endl;

    std::cout << "variables:" << std::endl;
    for (i = 0; i < vars.size(); ++i)
    {
        Variable v = vars.at(i);
        std::cout << "\t" << tname(v.type()) << " " << v.name()
                  << "(" << toString(v.dimensionNames())
                  << ") ;" << std::endl;

        Attributes const attrs = v.attributes();
        for (size_t j = 0; j < attrs.size(); ++j)
        {
            Attribute a = attrs.at(j);
            std::cout << "\t\t" << v.name() << ":" << attrs.keyAt(j) << " = "
                      << formatString(a.valuesAsString())
                      << " ;" << std::endl;
        }
    }
    std::cout << std::endl;

    std::cout << "// global attributes:" << std::endl;
    for (i = 0; i < attrs.size(); ++i)
    {
        Attribute a = attrs.at(i);
        std::cout << "\t\t:" << attrs.keyAt(i) << " = "
                  << formatString(a.valuesAsString())
                  << " ;" << std::endl;
    }
    std::cout << std::endl;

    std::cout << "data:" << std::endl;
    for (i = 0; i < vars.size(); ++i)
    {
        Variable v = vars.at(i);
        std::cout << std::endl << " " << v.name() << " =" << std::endl;
        std::cout << "  " << file.valueAsString(v, 0, 0, 0)
                  << ", " << file.valueAsString(v, 1, 0, 0)
                  << ", " << file.valueAsString(v, 2, 0, 0)
                  << ", " << file.valueAsString(v, 3, 0, 0)
                  << ", " << file.valueAsString(v, 4, 0, 0)
                  << ", ... ;"
                  << std::endl;
    }

    std::cout << "}" << std::endl;
}