Returns an object which is generated from a buffer including the
        expression of the wire protocol of the flow stats.
490582
def parser(cls, buf, offset):
        
        stats = OFPStats()
        reserved, length = struct.unpack_from('!HH', buf, offset)

        stats.length = length

        # ofp_stats adjustment
        offset += 4
        length -= 4

        fields = []
        while length > 0:
            n, value, _, field_len = ofproto.oxs_parse(buf, offset)
            k, uv = ofproto.oxs_to_user(n, value, None)  # No mask
            fields.append((k, uv))
            offset += field_len
            length -= field_len
        stats.fields = fields
        return stats
914718
public static final Object getImpl(Object obj) {
        InvocationHandler handler;

        return Proxy.isProxyClass(obj.getClass()) && (handler = Proxy.getInvocationHandler(obj)) instanceof WSJdbcTracer ? ((WSJdbcTracer) handler).impl : obj;
    }
489371
private FastBlobStateEngine getDeserializedStateEngineWithObjects(A... objects) throws IOException {
        FastBlobStateEngine stateEngine = new FastBlobStateEngine(new ExampleSerializerFactory());

        for(A object : objects) {
            stateEngine.add("A", object);
        }

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(baos);

        stateEngine.prepareForWrite();

        FastBlobWriter writer = new FastBlobWriter(stateEngine);
        writer.writeSnapshot(dataOutputStream);

        FastBlobReader reader = new FastBlobReader(stateEngine);
        reader.readSnapshot(new ByteArrayInputStream(baos.toByteArray()));

        return stateEngine;
    }
311081
def getFeatureReport(self, report_num=0, length=63):
        
        length += 1
        buf = bytearray(length)
        buf[0] = report_num
        self._ioctl(
            _HIDIOCGFEATURE(length),
            (ctypes.c_char * length).from_buffer(buf),
            True,
        )
        return buf
646149
def _GetFlowArgsHelpAsString(self, flow_cls):
    """"""
    output = [
        "  Call Spec:",
        "    %s" % self._GetCallingPrototypeAsString(flow_cls), ""
    ]
    arg_list = sorted(
        iteritems(self._GetArgsDescription(flow_cls.args_type)),
        key=lambda x: x[0])
    if not arg_list:
      output.append("  Args: None")
    else:
      output.append("  Args:")
      for arg, val in arg_list:
        output.append("    %s" % arg)
        output.append("      description: %s" % val["description"])
        output.append("      type: %s" % val["type"])
        output.append("      default: %s" % val["default"])
        output.append("")
    return "\n".join(output)
729706
def _bytes_generator(descriptor, max_length=0, limit=0):
    ''
    strs = values.get_strings(max_length, limit)
    vals = [bytes(_, 'utf-8') for _ in strs]
    return gen.IterValueGenerator(descriptor.name, vals)
786111
protected UDPBufferImpl getUDPBufferImpl() {
        UDPBufferImpl ret = (UDPBufferImpl) udpBufferObjectPool.get();
        if (ret == null) {
            ret = new UDPBufferImpl(this);
        }
        return ret;
    }
76338
private ClientSocketStats getOrCreateNodeStats(SocketDestination destination) {
        if(destination == null) {
            return null;
        }
        ClientSocketStats stats = statsMap.get(destination);
        if(stats == null) {
            ClientSocketStats socketStats = new ClientSocketStats(this,
                                                                  destination,
                                                                  pool,
                                                                  identifierString);
            // The idea here is to avoid registering the bean multiple times.
            // This can happen when
            // two threads, both read the stats object as null (three lines
            // above) and then try to
            // populate the map with their own socketStats object. putifabsent
            // returns the existing
            // value if the key exists or returns null. The thread that does the
            // first put will
            // get a null return vale. That thread will then go on to get the
            // stats object and register
            // the bean. All the other threads will have their stats object
            // populated by the return
            // value of the putIfAbsent call that will return the existing value
            // in the map.
            stats = statsMap.putIfAbsent(destination, socketStats);
            if(stats == null) {
                stats = socketStats;
                JmxUtils.registerMbean(new ClientSocketStatsJmx(stats),
                                       JmxUtils.createObjectName(JmxUtils.getPackageName(ClientRequestExecutor.class),
                                                                 "stats_"
                                                                         + destination.toString()
                                                                                      .replace(':',
                                                                                               '_')
                                                                         + identifierString));
            }
        }
        return stats;
    }
1121501
def get_node(self,obj,cls=type(None),hist={}):
        
        #~ ident = getattr(obj,'ident',obj)
        if obj in self.modules and is_module(obj,cls):
            return self.modules[obj]
        elif obj in self.submodules and is_submodule(obj,cls):
            return self.submodules[obj]
        elif obj in self.types and is_type(obj,cls):
            return self.types[obj]
        elif obj in self.procedures and is_proc(obj,cls):
            return self.procedures[obj]
        elif obj in self.programs and is_program(obj,cls):
            return self.programs[obj]
        elif obj in self.sourcefiles and is_sourcefile(obj,cls):
            return self.sourcefiles[obj]
        elif obj in self.blockdata and is_blockdata(obj,cls):
            return self.blockdata[obj]
        else:
            self.register(obj,cls,hist)
            return self.get_node(obj,cls,hist)
868586
public int getInstanceSlot(Instruction ins, ConstantPoolGen cpg) throws DataflowAnalysisException {
        if (!isValid()) {
            throw new DataflowAnalysisException("Accessing invalid frame at " + ins);
        }
        int numConsumed = ins.consumeStack(cpg);
        if (numConsumed == Const.UNPREDICTABLE) {
            throw new DataflowAnalysisException("Unpredictable stack consumption in " + ins);
        }
        if (numConsumed > getStackDepth()) {
            throw new DataflowAnalysisException("Stack underflow " + ins);
        }
        return getNumSlots() - numConsumed;
    }
144198
def Get(self):
    """"""

    args = flow_pb2.ApiGetFlowArgs(
        client_id=self.client_id, flow_id=self.flow_id)
    data = self._context.SendRequest("GetFlow", args)
    return Flow(data=data, context=self._context)
717320
def getPayloadStruct(self, attributes, objType):
        
        payload = {self.payloadObj: attributes,
                   objType + "_class":
                       {self.payloadObj: attributes}}
        return payload
3416
def factory(cls, object_source):
        
        if object_source.type is ObjectRaw.Types.object:
            return ObjectObject(object_source)
        elif object_source.type not in ObjectRaw.Types or object_source.type is ObjectRaw.Types.type:
            return ObjectType(object_source)
        elif object_source.type is ObjectRaw.Types.array:
            return ObjectArray(object_source)
        elif object_source.type is ObjectRaw.Types.dynamic:
            return ObjectDynamic(object_source)
        elif object_source.type is ObjectRaw.Types.const:
            return ObjectConst(object_source)
        elif object_source.type is ObjectRaw.Types.enum:
            return ObjectEnum(object_source)
        else:
            return Object(object_source)
740773
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return ExecutionContextInstance(
            self._version,
            payload,
            flow_sid=self._solution['flow_sid'],
            execution_sid=self._solution['execution_sid'],
        )
812191
def ReadFlowObject(self, client_id, flow_id, cursor=None):
    """"""
    query = ("SELECT " + self.FLOW_DB_FIELDS +
             "FROM flows WHERE client_id=%s AND flow_id=%s")
    cursor.execute(
        query,
        [db_utils.ClientIDToInt(client_id),
         db_utils.FlowIDToInt(flow_id)])
    result = cursor.fetchall()
    if not result:
      raise db.UnknownFlowError(client_id, flow_id)
    row, = result
    return self._FlowObjectFromRow(row)
1078264
private ByteBuffer getBytesAccordingToType(String object, AbstractType<?> comparator)
    {
        if (comparator == null) // default comparator is BytesType
            comparator = BytesType.instance;

        try
        {
            return comparator.fromString(object);
        }
        catch (MarshalException e)
        {
            throw new RuntimeException(e);
        }
    }
883476
def get_blen(self):
        """"""

        try:
            ret = fcntl.ioctl(self.ins, BIOCGBLEN, struct.pack("I", 0))
            return struct.unpack("I", ret)[0]
        except IOError:
            warning("Unable to get the BPF buffer length")
            return