I am in the process of learning Rust and am still having some issues with borrowing and ownership. I find myself trying to borrow mutable references that are already borrowed as immutable references etc...  I noticed that when I try to iterate over the primes without owning them, I encounter issues trying to modify the composites hash map. I was able to get around this by calling to_owned on the vector. Is this the right way to handle this?  This uses the .  cargo -V  cargo 1.35.0-nightly (0e35bd8af 2019-03-13)   #![feature(generators, generator_trait)]  use std::collections::HashMap; use std::ops::{Generator, GeneratorState};  let mut sieve = || {     let mut x: u32 = 2;     let mut composites: HashMap&lt;u32, Vec&lt;u32&gt;&gt; = HashMap::new();      loop {         match composites.get(&amp;x) {             Some(primes) =&gt; {                 for _prime in primes.to_owned() {                     composites                         .entry(x + _prime)                         .and_modify(|v| v.push(_prime))                         .or_insert(vec![_prime]);                     composites.remove(&amp;x);                 }             }             None =&gt; {                 yield x;                 composites.insert(x * x, vec![x]);             }         }          x = x + 1;     } };
124250
I am in the process of learning Rust and am still having some issues with borrowing and ownership. I find myself trying to borrow mutable references that are already borrowed as immutable references etc...  I noticed that when I try to iterate over the primes without owning them, I encounter issues trying to modify the composites hash map. I was able to get around this by calling to_owned on the vector. Is this the right way to handle this?  I also see that when I build the code, I get warnings about unused code for warning: struct is never constructed: 'Sieve' and warning: method is never used: 'new', am I constructing them incorrectly?  use std::collections::HashMap;  struct Sieve {     composites: HashMap&lt;u64, Vec&lt;u64&gt;&gt;,     x: u64, }  impl Sieve {     fn new() -&gt; Sieve {         Sieve {             composites: HashMap::new(),             x: 2,         }     } }  impl Iterator for Sieve {     type Item = u64;      fn next(&amp;mut self) -&gt; Option&lt;u64&gt; {         let x = self.x;         self.x = self.x + 1;         match self.composites.get(&amp;x) {             Some(numbers) =&gt; {                 for _num in numbers.to_owned() {                     self.composites                         .entry(x + _num)                         .and_modify(|v| v.push(_num))                         .or_insert(vec![_num]);                 }                 self.composites.remove(&amp;x);                 self.next()             }             None =&gt; {                 self.composites.insert(x * x, vec![x]);                 Some(x)             }         }     } }  fn main() {     let mut sieve = Sieve::new();      println!("{:?}", sieve.next()); // 2     println!("{:?}", sieve.next()); // 3     println!("{:?}", sieve.next()); // 5     println!("{:?}", sieve.next()); // 7 }   .  I , this made it difficult to get feedback on. I have refactored the code to use iterators
15076
I have code like this:  class RetInterface {...}  class Ret1: public RetInterface {...}  class AInterface {   public:      virtual boost::shared_ptr&lt;RetInterface&gt; get_r() const = 0;      ... };  class A1: public AInterface {   public:      boost::shared_ptr&lt;Ret1&gt; get_r() const {...}      ... };   This code does not compile.  In visual studio it raises     C2555: overriding virtual function return type differs and is not   covariant   If I do not use boost::shared_ptr but return raw pointers, the code compiles (I understand this is due to  in C++). I can see the problem is because boost::shared_ptr of Ret1 is not derived from boost::shared_ptr of RetInterface. But I want to return boost::shared_ptr of Ret1 for use in other classes, else I must cast the returned value after the return.      Am I doing something wrong?  If not, why is the language like this - it should be extensible to handle conversion between smart pointers in this scenario? Is there a desirable workaround?
9893
Let's say I have the following class X where I want to return access to an internal member:  class Z {     // details };  class X {     std::vector&lt;Z&gt; vecZ;  public:     Z&amp; Z(size_t index)     {         // massive amounts of code for validating index          Z&amp; ret = vecZ[index];          // even more code for determining that the Z instance         // at index is *exactly* the right sort of Z (a process         // which involves calculating leap years in which         // religious holidays fall on Tuesdays for         // the next thousand years or so)          return ret;     }     const Z&amp; Z(size_t index) const     {         // identical to non-const X::Z(), except printed in         // a lighter shade of gray since         // we're running low on toner by this point     } };   The two member functions X::Z() and X::Z() const have identical code inside the braces.  This is duplicate code and can cause maintenance problems for long functions with complex logic.    Is there a way to avoid this code duplication?
50510
Whilst refactoring some code I came across some getter methods that returns a std::string.  Something like this for example:  class foo { private:     std::string name_; public:     std::string name()     {         return name_;     } };   Surely the getter would be better returning a const std::string&amp;?  The current method is returning a copy which isn't as efficient.  Would returning a const reference instead cause any problems?
13904
I'm doing some architectural cleanup that involves moving a bunch of classes into different projects and/or namespaces. Currently I'm moving the files by hand, building, and then manually adding using Foo statements as needed to resolve compilation errors. Anyone know of a smarter way of doing this? (We're a CodeRush and Refactor! shop, but I'd be interested to hear if Resharper has support for this)
36762
Given the following class  public class Foo {     public int FooId { get; set; }     public string FooName { get; set; }      public override bool Equals(object obj)     {         Foo fooItem = obj as Foo;          if (fooItem == null)          {            return false;         }          return fooItem.FooId == this.FooId;     }      public override int GetHashCode()     {         // Which is preferred?          return base.GetHashCode();          //return this.FooId.GetHashCode();     } }   I have overridden the Equals method because Foo represent a row for the Foos table.  Which is the preferred method for overriding the GetHashCode?  Why is it important to override GetHashCode?
17383
How do I concatenate two std::vectors?
35955
I have a collection that contains linked assets. I would like to override their materials and give them a unique material. Is it possible to assign a material to a whole collection, and how ?  Thanks !
113672
For example:  &gt;&gt;&gt; x = [1, 1, 2, 'a', 'a', 3] &gt;&gt;&gt; unique(x) [1, 2, 'a', 3]   Assume list elements are hashable.  Clarification: The result should keep the first duplicate in the list. For example, [1, 2, 3, 2, 3, 1] becomes [1, 2, 3].
102371
A while ago, I had a discussion with a colleague about how to insert values in STL . I preferred map[key] = value; because it feels natural and is clear to read whereas he preferred map.insert(std::make_pair(key, value)). I just asked him and neither of us can remember the reason why insert is better, but I am sure it was not just a style preference rather there was a technical reason such as efficiency. The  simply says: &quot;Strictly speaking, this member function is unnecessary: it exists only for convenience.&quot; Can anybody tell me that reason, or am I just dreaming that there is one?
77424
My E/C implementation is the basic one where Entities are just ID's, Components are data and Systems act on the Data. Right now I'm having trouble with object materials and rendering in general. For simple objetcs I have a ModelComponent, tied to a RenderSystem, ModelComponent has the vertex buffer ids that the render system uses. A simple MaterialComponent would probably have color or specular strenght, etc, but I wanted it to be flexible enough to allow for more than one render pass and general "effects" that are not as easy as a simple variable in the MaterialComponent.  Trying to solve these problems I came up with two solutions:  1 - Super-generic Material Component  Something like this:  struct Material : public Component {     ShaderData* shader;     std::vector&lt;std::pair&lt;std::string, boost::any&gt;&gt; uniforms;     [...] };   and in the render system I would loop and pass the uniforms to the shader. I suppose this would be slow, but fast enough for my purposes.  2 - Another layer of abstraction, MaterialData  Having a class to wrap specific materials, that could be inherited by whatever specialized  material, the base class would have something like void set_shader_constants(ShaderData* d) but the implementation is up to each class, and the MaterialComponent would have a pointer to a MaterialData object.  I'm not sure which approach I would prefer, but neither of these touch the subject of multiple passes, or other complex rendering techniques.  Any idea on how to accomplish this?
94076
How can I represent the  (i.e, vec(A))? I am talking about this simple operator:
65649
Here's the use case. When a lead is converted to an Opportunity, I want to automatically share the opportunity with the previous owner of the lead. This is needed because upon conversion, the opportunity ownership is granted to someone else but the original lead owner needs ongoing access to the opportunity.  So:   A partner submits/creates a lead and is the lead owner Lead is converted to opportunity and internal sales person gains ownership Original partner needs to have view/edit access on this opportunity   I know you can use Apex Managed Sharing to share a custom object, but I'm hitting a wall trying to do this with an opportunity since the fields in OpportunityShare are not writable. The following won't even compile as a result:  List&lt;OpportunityShare&gt; oppShares = new List&lt;OpportunityShare&gt;(); for(Id i : oppIds) {    OpportunityShare os = new OpportunityShare(OpportunityId = i);    os.OpportunityId = i; // *** ERROR - not writable ***    os.OpportunityAccessLevel = 'Read/Write';    os.UserOrGroupId = oppIdToLead.get(i).OwnerId;    os.RowCause = 'Manual Sharing';    oppShares.add(os); }  Database.SaveResult[] result = Database.insert(oppShares, false);
102352
I have a HashMap (although I guess this question applies to other collections) of objects. From what I understand, when the documentation talks about removing mappings, then it is removing the entry from the hashtable, i.e. not necessarily destroying the actual object. If the only remaining reference to the object is in this table, then will the object get garbage collected?  If I do map.clear() and those objects that were in the table are not referenced anywhere else, will they get garbage collected?  What is the fastest way, to actually remove all entries from the table, but also destroy those objects.
39892
Why is it wrong to use std::auto_ptr&lt;&gt; with standard containers?
46281
In Dan Appleman's book Advanced Apex Programming, he explains how using SObjects as Map keys (i.e. Map&lt;SObject, *value*&gt;) is supported but it's poor practice, since the key is actually determined by a hash of all the fields on that SObject key - so if there's a change to even just one field, the key is changed.   My question is - why is this supported? I'm having trouble thinking of even one case where using this type of collection would be desired? The point of using a Map is to be able to retrieve data based on semantic-trivial, immutable data (such as IDs)...
117860
Given a struct like this:  public struct SomeStruct {     public SomeStruct(String stringProperty, Int32 intProperty)     {         this.StringProperty = stringProperty;         this.IntProperty = intProperty;     }      public String StringProperty { get; set; }     public Int32 IntProperty { get; set; } }   Of course, a compiler error is generated that reads The 'this' object cannot be used before all of its fields are assigned to.  Is there a way to assign values to the backing fields or the properties themselves, or do I have to implement properties the old-fashioned way with my own explicit backing fields?